From dc7911de53dee526dcf8564518e52330692b7dcc Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Mat=C3=ADas=20Saguir?= <mativs@gmail.com>
Date: Fri, 10 Jan 2025 09:41:31 -0300
Subject: [PATCH 01/14] first release of the rest framework challenge

---
 .../backend/custom_rest_framework/Pipfile     |  13 ++
 .../custom_rest_framework/Pipfile.lock        |  55 +++++++
 .../custom_rest_framework/challenge.md        |  25 ++++
 .../custom_rest_framework/__init__.py         |   0
 .../custom_rest_framework/admin.py            |   3 +
 .../custom_rest_framework/apps.py             |   6 +
 .../migrations/0001_initial.py                |  35 +++++
 .../migrations/__init__.py                    |   0
 .../custom_rest_framework/models.py           |  16 ++
 .../custom_rest_framework/tests.py            | 141 ++++++++++++++++++
 .../custom_rest_framework/views.py            |   3 +
 .../backend/custom_rest_framework/manage.py   |  22 +++
 .../custom_rest_framework/server/__init__.py  |   0
 .../custom_rest_framework/server/asgi.py      |  16 ++
 .../custom_rest_framework/server/settings.py  | 127 ++++++++++++++++
 .../custom_rest_framework/server/urls.py      |  23 +++
 .../custom_rest_framework/server/wsgi.py      |  16 ++
 17 files changed, 501 insertions(+)
 create mode 100644 profile-specific-challenges/backend/custom_rest_framework/Pipfile
 create mode 100644 profile-specific-challenges/backend/custom_rest_framework/Pipfile.lock
 create mode 100644 profile-specific-challenges/backend/custom_rest_framework/challenge.md
 create mode 100644 profile-specific-challenges/backend/custom_rest_framework/custom_rest_framework/__init__.py
 create mode 100644 profile-specific-challenges/backend/custom_rest_framework/custom_rest_framework/admin.py
 create mode 100644 profile-specific-challenges/backend/custom_rest_framework/custom_rest_framework/apps.py
 create mode 100644 profile-specific-challenges/backend/custom_rest_framework/custom_rest_framework/migrations/0001_initial.py
 create mode 100644 profile-specific-challenges/backend/custom_rest_framework/custom_rest_framework/migrations/__init__.py
 create mode 100644 profile-specific-challenges/backend/custom_rest_framework/custom_rest_framework/models.py
 create mode 100644 profile-specific-challenges/backend/custom_rest_framework/custom_rest_framework/tests.py
 create mode 100644 profile-specific-challenges/backend/custom_rest_framework/custom_rest_framework/views.py
 create mode 100755 profile-specific-challenges/backend/custom_rest_framework/manage.py
 create mode 100644 profile-specific-challenges/backend/custom_rest_framework/server/__init__.py
 create mode 100644 profile-specific-challenges/backend/custom_rest_framework/server/asgi.py
 create mode 100644 profile-specific-challenges/backend/custom_rest_framework/server/settings.py
 create mode 100644 profile-specific-challenges/backend/custom_rest_framework/server/urls.py
 create mode 100644 profile-specific-challenges/backend/custom_rest_framework/server/wsgi.py

diff --git a/profile-specific-challenges/backend/custom_rest_framework/Pipfile b/profile-specific-challenges/backend/custom_rest_framework/Pipfile
new file mode 100644
index 00000000..878700a6
--- /dev/null
+++ b/profile-specific-challenges/backend/custom_rest_framework/Pipfile
@@ -0,0 +1,13 @@
+[[source]]
+url = "https://pypi.org/simple"
+verify_ssl = true
+name = "pypi"
+
+[packages]
+django = "*"
+djangorestframework = "*"
+
+[dev-packages]
+
+[requires]
+python_version = "3.12"
diff --git a/profile-specific-challenges/backend/custom_rest_framework/Pipfile.lock b/profile-specific-challenges/backend/custom_rest_framework/Pipfile.lock
new file mode 100644
index 00000000..c84b7ea5
--- /dev/null
+++ b/profile-specific-challenges/backend/custom_rest_framework/Pipfile.lock
@@ -0,0 +1,55 @@
+{
+    "_meta": {
+        "hash": {
+            "sha256": "709498677962b597deb7755151c892205b5602857f054bab7de772221152085a"
+        },
+        "pipfile-spec": 6,
+        "requires": {
+            "python_version": "3.12"
+        },
+        "sources": [
+            {
+                "name": "pypi",
+                "url": "https://pypi.org/simple",
+                "verify_ssl": true
+            }
+        ]
+    },
+    "default": {
+        "asgiref": {
+            "hashes": [
+                "sha256:3e1e3ecc849832fe52ccf2cb6686b7a55f82bb1d6aee72a58826471390335e47",
+                "sha256:c343bd80a0bec947a9860adb4c432ffa7db769836c64238fc34bdc3fec84d590"
+            ],
+            "markers": "python_version >= '3.8'",
+            "version": "==3.8.1"
+        },
+        "django": {
+            "hashes": [
+                "sha256:236e023f021f5ce7dee5779de7b286565fdea5f4ab86bae5338e3f7b69896cf0",
+                "sha256:de450c09e91879fa5a307f696e57c851955c910a438a35e6b4c895e86bedc82a"
+            ],
+            "index": "pypi",
+            "markers": "python_version >= '3.10'",
+            "version": "==5.1.4"
+        },
+        "djangorestframework": {
+            "hashes": [
+                "sha256:2b8871b062ba1aefc2de01f773875441a961fefbf79f5eed1e32b2f096944b20",
+                "sha256:36fe88cd2d6c6bec23dca9804bab2ba5517a8bb9d8f47ebc68981b56840107ad"
+            ],
+            "index": "pypi",
+            "markers": "python_version >= '3.8'",
+            "version": "==3.15.2"
+        },
+        "sqlparse": {
+            "hashes": [
+                "sha256:09f67787f56a0b16ecdbde1bfc7f5d9c3371ca683cfeaa8e6ff60b4807ec9272",
+                "sha256:cf2196ed3418f3ba5de6af7e82c694a9fbdbfecccdfc72e281548517081f16ca"
+            ],
+            "markers": "python_version >= '3.8'",
+            "version": "==0.5.3"
+        }
+    },
+    "develop": {}
+}
diff --git a/profile-specific-challenges/backend/custom_rest_framework/challenge.md b/profile-specific-challenges/backend/custom_rest_framework/challenge.md
new file mode 100644
index 00000000..c22650e2
--- /dev/null
+++ b/profile-specific-challenges/backend/custom_rest_framework/challenge.md
@@ -0,0 +1,25 @@
+# Django Rest Framework Challenge
+
+## 1. Implement a custom version of Model Serializer 
+
+You must implement a custom version of the class `ModelSerializer` that is provided by the `restframework` library with the following features:
+
+1. The fields should be populated automatically based on the `Meta` `fields` parameters 
+2. Implement `CharField`, `IntegerField`, `BooleanField`, `FloatField`, `EmailField` and `SlugField`
+3. Implement `read_only` and `write_only` parameters 
+4. Implement `read`, `create` and `write` operations for the serializer
+5. Create validations for `IntegerField`, `BooleanField`, `EmailField`, `SlugField`
+
+The app `custom_rest_framework` has already been created with a dummy model `TestSerializerModel` with the required columns. 
+
+A test file is already created with all tests working fine. 
+
+You should change the import from the original `restframework` and import your custom one while having the test still working fine. 
+
+For running the tests you should first install the depending library and then run the test
+
+```
+$ pipenv install
+$ pipenv shell
+$ python manage.py test
+```
\ No newline at end of file
diff --git a/profile-specific-challenges/backend/custom_rest_framework/custom_rest_framework/__init__.py b/profile-specific-challenges/backend/custom_rest_framework/custom_rest_framework/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/profile-specific-challenges/backend/custom_rest_framework/custom_rest_framework/admin.py b/profile-specific-challenges/backend/custom_rest_framework/custom_rest_framework/admin.py
new file mode 100644
index 00000000..8c38f3f3
--- /dev/null
+++ b/profile-specific-challenges/backend/custom_rest_framework/custom_rest_framework/admin.py
@@ -0,0 +1,3 @@
+from django.contrib import admin
+
+# Register your models here.
diff --git a/profile-specific-challenges/backend/custom_rest_framework/custom_rest_framework/apps.py b/profile-specific-challenges/backend/custom_rest_framework/custom_rest_framework/apps.py
new file mode 100644
index 00000000..7cb50274
--- /dev/null
+++ b/profile-specific-challenges/backend/custom_rest_framework/custom_rest_framework/apps.py
@@ -0,0 +1,6 @@
+from django.apps import AppConfig
+
+
+class RestframeworkConfig(AppConfig):
+    default_auto_field = "django.db.models.BigAutoField"
+    name = "custom_rest_framework"
diff --git a/profile-specific-challenges/backend/custom_rest_framework/custom_rest_framework/migrations/0001_initial.py b/profile-specific-challenges/backend/custom_rest_framework/custom_rest_framework/migrations/0001_initial.py
new file mode 100644
index 00000000..02d28254
--- /dev/null
+++ b/profile-specific-challenges/backend/custom_rest_framework/custom_rest_framework/migrations/0001_initial.py
@@ -0,0 +1,35 @@
+# Generated by Django 5.1.4 on 2025-01-10 12:01
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    initial = True
+
+    dependencies = []
+
+    operations = [
+        migrations.CreateModel(
+            name="TestSerializerModel",
+            fields=[
+                (
+                    "id",
+                    models.BigAutoField(
+                        auto_created=True,
+                        primary_key=True,
+                        serialize=False,
+                        verbose_name="ID",
+                    ),
+                ),
+                ("text", models.CharField(max_length=50)),
+                ("number", models.IntegerField()),
+                ("is_something", models.BooleanField()),
+                ("email", models.CharField(max_length=256)),
+                ("slug", models.CharField(max_length=64)),
+                ("real", models.FloatField()),
+                ("password", models.CharField(max_length=50)),
+                ("generated", models.CharField(max_length=256)),
+            ],
+        ),
+    ]
diff --git a/profile-specific-challenges/backend/custom_rest_framework/custom_rest_framework/migrations/__init__.py b/profile-specific-challenges/backend/custom_rest_framework/custom_rest_framework/migrations/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/profile-specific-challenges/backend/custom_rest_framework/custom_rest_framework/models.py b/profile-specific-challenges/backend/custom_rest_framework/custom_rest_framework/models.py
new file mode 100644
index 00000000..352143a9
--- /dev/null
+++ b/profile-specific-challenges/backend/custom_rest_framework/custom_rest_framework/models.py
@@ -0,0 +1,16 @@
+from django.db import models
+
+
+class TestSerializerModel(models.Model):
+    text = models.CharField(max_length=50)
+    number = models.IntegerField()
+    is_something = models.BooleanField()
+    email = models.CharField(max_length=256)
+    slug = models.CharField(max_length=64)
+    real = models.FloatField()
+    password = models.CharField(max_length=50)
+    generated = models.CharField(max_length=256)
+
+    def save(self, *args, **kwargs):
+        self.generated = f"{self.slug}:{str(self.number)}"
+        super().save()
diff --git a/profile-specific-challenges/backend/custom_rest_framework/custom_rest_framework/tests.py b/profile-specific-challenges/backend/custom_rest_framework/custom_rest_framework/tests.py
new file mode 100644
index 00000000..9f33224b
--- /dev/null
+++ b/profile-specific-challenges/backend/custom_rest_framework/custom_rest_framework/tests.py
@@ -0,0 +1,141 @@
+import random
+from typing import Any
+
+from django.test import TestCase
+from rest_framework.serializers import EmailField, ModelSerializer, SlugField, CharField
+
+from .models import TestSerializerModel
+# from .serializers import EmailField, ModelSerializer, SlugField, CharField
+
+
+# Create your tests here.
+class TestModelSerializer(ModelSerializer):
+    email = EmailField()
+    slug = SlugField()
+    password = CharField(write_only=True)
+
+    class Meta:
+        model = TestSerializerModel
+        fields = [
+            "text",
+            "number",
+            "is_something",
+            "email",
+            "slug",
+            "real",
+            "password",
+            "generated",
+        ]
+        read_only_fields = ["generated"]
+
+
+class TestSerializer(TestCase):
+    def create_random_data(self) -> dict:
+        """Creates random data for test purposes."""
+        return dict(
+            text=str(random.randint(1000, 2000)),
+            number=random.randint(0, 1000),
+            is_something=random.choices([True, False])[0],
+            slug=str(random.randint(1000, 2000)),
+            email=f"{str(random.randint(10000, 20000))}@{random.randint(1000,2000)}.com",
+            real=random.randint(1000, 9999) / 100,
+            password=str(random.randint(100000, 999999)),
+        )
+
+    def assertInstance(self, instance: Any, data: dict):
+        """Assert that all the values in the dictionary exists as a property in the
+        instance."""
+        for k, v in data.items():
+            assert hasattr(instance, k)
+            assert getattr(instance, k) == v
+
+    def test_read(self):
+        """We create a model on DB and then check the serialized data is correct."""
+        data = self.create_random_data()
+        instance = TestSerializerModel.objects.create(**data)
+        serializer = TestModelSerializer(instance)
+        self.assertInstance(instance, serializer.data)
+
+    def test_write_only(self):
+        """We create a model on DB and then check the serialized data without the
+        write only field."""
+        data = self.create_random_data()
+        instance = TestSerializerModel.objects.create(**data)
+        serializer = TestModelSerializer(instance)
+        serialized_data = serializer.data
+        self.assertInstance(instance, serialized_data)
+        self.assertFalse("password" in serialized_data)
+
+    def test_create(self):
+        """We create a model through the serializer and check that it was created
+        correctly in DB."""
+        data = self.create_random_data()
+        serializer = TestModelSerializer(data=data)
+        self.assertTrue(serializer.is_valid())
+        serializer.save()
+        instance = TestSerializerModel.objects.last()
+        self.assertInstance(instance, data)
+
+    def test_read_only(self):
+        """We create a model through the serializer and check that it was created
+        correctly skipping the write only field."""
+        data = self.create_random_data()
+        data["generated"] = "fixed"
+        serializer = TestModelSerializer(data=data)
+        self.assertTrue(serializer.is_valid())
+        serializer.save()
+
+        del data["generated"]
+        instance = TestSerializerModel.objects.last()
+        self.assertInstance(instance, data)
+        self.assertNotEqual(instance.generated, "fixed")
+
+    def test_update(self):
+        """We update a model through the serializer and check that the values were
+        correctly updated in DB."""
+        data = self.create_random_data()
+        instance = TestSerializerModel.objects.create(**data)
+        previous_count = TestSerializerModel.objects.count()
+        new_data = self.create_random_data()
+        serializer = TestModelSerializer(instance, data=new_data)
+        self.assertTrue(serializer.is_valid())
+        serializer.save()
+        self.assertEqual(previous_count, TestSerializerModel.objects.count())
+        new_instance = TestSerializerModel.objects.get(id=instance.id)
+        self.assertInstance(new_instance, new_data)
+
+    def test_error_int(self):
+        """We force an error on creation on the number field."""
+        data = self.create_random_data()
+        data["number"] = "15.5"
+        serializer = TestModelSerializer(data=data)
+        self.assertFalse(serializer.is_valid())
+        self.assertEqual(len(serializer.errors), 1)
+        self.assertTrue("number" in serializer.errors)
+
+    def test_error_bool(self):
+        """We force an error on creation on the bool field."""
+        data = self.create_random_data()
+        data["is_something"] = "jojo"
+        serializer = TestModelSerializer(data=data)
+        self.assertFalse(serializer.is_valid())
+        self.assertEqual(len(serializer.errors), 1)
+        self.assertTrue("is_something" in serializer.errors)
+
+    def test_error_email(self):
+        """We force an error on creation on the email field."""
+        data = self.create_random_data()
+        data["email"] = "not_an_email"
+        serializer = TestModelSerializer(data=data)
+        self.assertFalse(serializer.is_valid())
+        self.assertEqual(len(serializer.errors), 1)
+        self.assertTrue("email" in serializer.errors)
+
+    def test_error_slug(self):
+        """We force an error on creation on the slug field."""
+        data = self.create_random_data()
+        data["slug"] = "not_an_slug./$"
+        serializer = TestModelSerializer(data=data)
+        self.assertFalse(serializer.is_valid())
+        self.assertEqual(len(serializer.errors), 1)
+        self.assertTrue("slug" in serializer.errors)
diff --git a/profile-specific-challenges/backend/custom_rest_framework/custom_rest_framework/views.py b/profile-specific-challenges/backend/custom_rest_framework/custom_rest_framework/views.py
new file mode 100644
index 00000000..91ea44a2
--- /dev/null
+++ b/profile-specific-challenges/backend/custom_rest_framework/custom_rest_framework/views.py
@@ -0,0 +1,3 @@
+from django.shortcuts import render
+
+# Create your views here.
diff --git a/profile-specific-challenges/backend/custom_rest_framework/manage.py b/profile-specific-challenges/backend/custom_rest_framework/manage.py
new file mode 100755
index 00000000..9856e029
--- /dev/null
+++ b/profile-specific-challenges/backend/custom_rest_framework/manage.py
@@ -0,0 +1,22 @@
+#!/usr/bin/env python
+"""Django's command-line utility for administrative tasks."""
+import os
+import sys
+
+
+def main():
+    """Run administrative tasks."""
+    os.environ.setdefault("DJANGO_SETTINGS_MODULE", "server.settings")
+    try:
+        from django.core.management import execute_from_command_line
+    except ImportError as exc:
+        raise ImportError(
+            "Couldn't import Django. Are you sure it's installed and "
+            "available on your PYTHONPATH environment variable? Did you "
+            "forget to activate a virtual environment?"
+        ) from exc
+    execute_from_command_line(sys.argv)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/profile-specific-challenges/backend/custom_rest_framework/server/__init__.py b/profile-specific-challenges/backend/custom_rest_framework/server/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/profile-specific-challenges/backend/custom_rest_framework/server/asgi.py b/profile-specific-challenges/backend/custom_rest_framework/server/asgi.py
new file mode 100644
index 00000000..bb306865
--- /dev/null
+++ b/profile-specific-challenges/backend/custom_rest_framework/server/asgi.py
@@ -0,0 +1,16 @@
+"""
+ASGI config for server project.
+
+It exposes the ASGI callable as a module-level variable named ``application``.
+
+For more information on this file, see
+https://docs.djangoproject.com/en/5.1/howto/deployment/asgi/
+"""
+
+import os
+
+from django.core.asgi import get_asgi_application
+
+os.environ.setdefault("DJANGO_SETTINGS_MODULE", "server.settings")
+
+application = get_asgi_application()
diff --git a/profile-specific-challenges/backend/custom_rest_framework/server/settings.py b/profile-specific-challenges/backend/custom_rest_framework/server/settings.py
new file mode 100644
index 00000000..e0254934
--- /dev/null
+++ b/profile-specific-challenges/backend/custom_rest_framework/server/settings.py
@@ -0,0 +1,127 @@
+"""
+Django settings for server project.
+
+Generated by 'django-admin startproject' using Django 5.1.4.
+
+For more information on this file, see
+https://docs.djangoproject.com/en/5.1/topics/settings/
+
+For the full list of settings and their values, see
+https://docs.djangoproject.com/en/5.1/ref/settings/
+"""
+
+from pathlib import Path
+
+# Build paths inside the project like this: BASE_DIR / 'subdir'.
+BASE_DIR = Path(__file__).resolve().parent.parent
+
+
+# Quick-start development settings - unsuitable for production
+# See https://docs.djangoproject.com/en/5.1/howto/deployment/checklist/
+
+# SECURITY WARNING: keep the secret key used in production secret!
+SECRET_KEY = "django-insecure-^jwo-=8d0i)7v41o0tpp&#%hk01gd&w*9pfnt11j@9-9&=k@%v"
+
+# SECURITY WARNING: don't run with debug turned on in production!
+DEBUG = True
+
+ALLOWED_HOSTS = []
+
+
+# Application definition
+
+INSTALLED_APPS = [
+    "django.contrib.admin",
+    "django.contrib.auth",
+    "django.contrib.contenttypes",
+    "django.contrib.sessions",
+    "django.contrib.messages",
+    "django.contrib.staticfiles",
+    # Libs
+    "rest_framework",
+    # Own
+    "custom_rest_framework",
+]
+
+MIDDLEWARE = [
+    "django.middleware.security.SecurityMiddleware",
+    "django.contrib.sessions.middleware.SessionMiddleware",
+    "django.middleware.common.CommonMiddleware",
+    "django.middleware.csrf.CsrfViewMiddleware",
+    "django.contrib.auth.middleware.AuthenticationMiddleware",
+    "django.contrib.messages.middleware.MessageMiddleware",
+    "django.middleware.clickjacking.XFrameOptionsMiddleware",
+]
+
+ROOT_URLCONF = "server.urls"
+
+TEMPLATES = [
+    {
+        "BACKEND": "django.template.backends.django.DjangoTemplates",
+        "DIRS": [],
+        "APP_DIRS": True,
+        "OPTIONS": {
+            "context_processors": [
+                "django.template.context_processors.debug",
+                "django.template.context_processors.request",
+                "django.contrib.auth.context_processors.auth",
+                "django.contrib.messages.context_processors.messages",
+            ],
+        },
+    },
+]
+
+WSGI_APPLICATION = "server.wsgi.application"
+
+
+# Database
+# https://docs.djangoproject.com/en/5.1/ref/settings/#databases
+
+DATABASES = {
+    "default": {
+        "ENGINE": "django.db.backends.sqlite3",
+        "NAME": BASE_DIR / "db.sqlite3",
+    }
+}
+
+
+# Password validation
+# https://docs.djangoproject.com/en/5.1/ref/settings/#auth-password-validators
+
+AUTH_PASSWORD_VALIDATORS = [
+    {
+        "NAME": "django.contrib.auth.password_validation.UserAttributeSimilarityValidator",
+    },
+    {
+        "NAME": "django.contrib.auth.password_validation.MinimumLengthValidator",
+    },
+    {
+        "NAME": "django.contrib.auth.password_validation.CommonPasswordValidator",
+    },
+    {
+        "NAME": "django.contrib.auth.password_validation.NumericPasswordValidator",
+    },
+]
+
+
+# Internationalization
+# https://docs.djangoproject.com/en/5.1/topics/i18n/
+
+LANGUAGE_CODE = "en-us"
+
+TIME_ZONE = "UTC"
+
+USE_I18N = True
+
+USE_TZ = True
+
+
+# Static files (CSS, JavaScript, Images)
+# https://docs.djangoproject.com/en/5.1/howto/static-files/
+
+STATIC_URL = "static/"
+
+# Default primary key field type
+# https://docs.djangoproject.com/en/5.1/ref/settings/#default-auto-field
+
+DEFAULT_AUTO_FIELD = "django.db.models.BigAutoField"
diff --git a/profile-specific-challenges/backend/custom_rest_framework/server/urls.py b/profile-specific-challenges/backend/custom_rest_framework/server/urls.py
new file mode 100644
index 00000000..4aa6dfa0
--- /dev/null
+++ b/profile-specific-challenges/backend/custom_rest_framework/server/urls.py
@@ -0,0 +1,23 @@
+"""
+URL configuration for server project.
+
+The `urlpatterns` list routes URLs to views. For more information please see:
+    https://docs.djangoproject.com/en/5.1/topics/http/urls/
+Examples:
+Function views
+    1. Add an import:  from my_app import views
+    2. Add a URL to urlpatterns:  path('', views.home, name='home')
+Class-based views
+    1. Add an import:  from other_app.views import Home
+    2. Add a URL to urlpatterns:  path('', Home.as_view(), name='home')
+Including another URLconf
+    1. Import the include() function: from django.urls import include, path
+    2. Add a URL to urlpatterns:  path('blog/', include('blog.urls'))
+"""
+
+from django.contrib import admin
+from django.urls import path
+
+urlpatterns = [
+    path("admin/", admin.site.urls),
+]
diff --git a/profile-specific-challenges/backend/custom_rest_framework/server/wsgi.py b/profile-specific-challenges/backend/custom_rest_framework/server/wsgi.py
new file mode 100644
index 00000000..6db91fbc
--- /dev/null
+++ b/profile-specific-challenges/backend/custom_rest_framework/server/wsgi.py
@@ -0,0 +1,16 @@
+"""
+WSGI config for server project.
+
+It exposes the WSGI callable as a module-level variable named ``application``.
+
+For more information on this file, see
+https://docs.djangoproject.com/en/5.1/howto/deployment/wsgi/
+"""
+
+import os
+
+from django.core.wsgi import get_wsgi_application
+
+os.environ.setdefault("DJANGO_SETTINGS_MODULE", "server.settings")
+
+application = get_wsgi_application()

From 9b53ef7612203e34240844159bc3d86846136693 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Mat=C3=ADas=20Saguir?= <mativs@gmail.com>
Date: Fri, 10 Jan 2025 09:44:11 -0300
Subject: [PATCH 02/14] fix typos

---
 .../backend/custom_rest_framework/challenge.md                  | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/profile-specific-challenges/backend/custom_rest_framework/challenge.md b/profile-specific-challenges/backend/custom_rest_framework/challenge.md
index c22650e2..6ad76dff 100644
--- a/profile-specific-challenges/backend/custom_rest_framework/challenge.md
+++ b/profile-specific-challenges/backend/custom_rest_framework/challenge.md
@@ -16,7 +16,7 @@ A test file is already created with all tests working fine.
 
 You should change the import from the original `restframework` and import your custom one while having the test still working fine. 
 
-For running the tests you should first install the depending library and then run the test
+For running the tests you should first install `Django` and `restframework`
 
 ```
 $ pipenv install

From dad3c8ddd66c3f9b4a9e219fc6439d56d20df062 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Mat=C3=ADas=20Saguir?= <mativs@gmail.com>
Date: Fri, 10 Jan 2025 09:58:20 -0300
Subject: [PATCH 03/14] change challenge custom rest framework title

---
 .../backend/custom_rest_framework/challenge.md                | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/profile-specific-challenges/backend/custom_rest_framework/challenge.md b/profile-specific-challenges/backend/custom_rest_framework/challenge.md
index 6ad76dff..58e969df 100644
--- a/profile-specific-challenges/backend/custom_rest_framework/challenge.md
+++ b/profile-specific-challenges/backend/custom_rest_framework/challenge.md
@@ -1,6 +1,4 @@
-# Django Rest Framework Challenge
-
-## 1. Implement a custom version of Model Serializer 
+# Custom Model Serializer
 
 You must implement a custom version of the class `ModelSerializer` that is provided by the `restframework` library with the following features:
 

From ebfb1204222da52b499642bf3359bf61e880e6fb Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Mat=C3=ADas=20Saguir?= <mativs@gmail.com>
Date: Mon, 27 Jan 2025 16:30:33 -0300
Subject: [PATCH 04/14] improve readability on challange desxription

---
 .../backend/custom_rest_framework/challenge.md   | 16 +++++++---------
 1 file changed, 7 insertions(+), 9 deletions(-)

diff --git a/profile-specific-challenges/backend/custom_rest_framework/challenge.md b/profile-specific-challenges/backend/custom_rest_framework/challenge.md
index 58e969df..9b878b16 100644
--- a/profile-specific-challenges/backend/custom_rest_framework/challenge.md
+++ b/profile-specific-challenges/backend/custom_rest_framework/challenge.md
@@ -1,16 +1,14 @@
 # Custom Model Serializer
 
-You must implement a custom version of the class `ModelSerializer` that is provided by the `restframework` library with the following features:
+Your task is to implement a custom version of the `ModelSerializer` class, originally provided by the rest_framework library, with the following features:
 
-1. The fields should be populated automatically based on the `Meta` `fields` parameters 
-2. Implement `CharField`, `IntegerField`, `BooleanField`, `FloatField`, `EmailField` and `SlugField`
-3. Implement `read_only` and `write_only` parameters 
-4. Implement `read`, `create` and `write` operations for the serializer
-5. Create validations for `IntegerField`, `BooleanField`, `EmailField`, `SlugField`
+1. The serializer should automatically define its fields based on the `fields` parameter in the `Meta` class. 
+2. Implement support for the following field types: `CharField`, `IntegerField`, `BooleanField`, `FloatField`, `EmailField` and `SlugField`
+3. Implement the `read_only` and `write_only` parameters for the fields.
+4. Implement the following methods in the serializer: `read`, `create` and `write`.
+5. Implement proper validations for: `IntegerField`, `BooleanField`, `EmailField`, `SlugField`
 
-The app `custom_rest_framework` has already been created with a dummy model `TestSerializerModel` with the required columns. 
-
-A test file is already created with all tests working fine. 
+The app `custom_rest_framework` has already been created with a dummy model named `TestSerializerModel` with the necessary fields. Additionally, a test file has been pre-configured, containing all the necessary test cases.
 
 You should change the import from the original `restframework` and import your custom one while having the test still working fine. 
 

From 01d7ecc76e36910f9207b0d8520a59ac59dfccbd Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Mat=C3=ADas=20Saguir?= <mativs@gmail.com>
Date: Mon, 27 Jan 2025 17:12:08 -0300
Subject: [PATCH 05/14] reorder tests so it's more logical to resolve

---
 .../custom_rest_framework/tests.py            | 50 +++++++++----------
 1 file changed, 25 insertions(+), 25 deletions(-)

diff --git a/profile-specific-challenges/backend/custom_rest_framework/custom_rest_framework/tests.py b/profile-specific-challenges/backend/custom_rest_framework/custom_rest_framework/tests.py
index 9f33224b..c842cef4 100644
--- a/profile-specific-challenges/backend/custom_rest_framework/custom_rest_framework/tests.py
+++ b/profile-specific-challenges/backend/custom_rest_framework/custom_rest_framework/tests.py
@@ -37,7 +37,7 @@ def create_random_data(self) -> dict:
             number=random.randint(0, 1000),
             is_something=random.choices([True, False])[0],
             slug=str(random.randint(1000, 2000)),
-            email=f"{str(random.randint(10000, 20000))}@{random.randint(1000,2000)}.com",
+            email=f"{str(random.randint(10000, 20000))}@{random.randint(1000, 2000)}.com",
             real=random.randint(1000, 9999) / 100,
             password=str(random.randint(100000, 999999)),
         )
@@ -56,16 +56,6 @@ def test_read(self):
         serializer = TestModelSerializer(instance)
         self.assertInstance(instance, serializer.data)
 
-    def test_write_only(self):
-        """We create a model on DB and then check the serialized data without the
-        write only field."""
-        data = self.create_random_data()
-        instance = TestSerializerModel.objects.create(**data)
-        serializer = TestModelSerializer(instance)
-        serialized_data = serializer.data
-        self.assertInstance(instance, serialized_data)
-        self.assertFalse("password" in serialized_data)
-
     def test_create(self):
         """We create a model through the serializer and check that it was created
         correctly in DB."""
@@ -76,20 +66,6 @@ def test_create(self):
         instance = TestSerializerModel.objects.last()
         self.assertInstance(instance, data)
 
-    def test_read_only(self):
-        """We create a model through the serializer and check that it was created
-        correctly skipping the write only field."""
-        data = self.create_random_data()
-        data["generated"] = "fixed"
-        serializer = TestModelSerializer(data=data)
-        self.assertTrue(serializer.is_valid())
-        serializer.save()
-
-        del data["generated"]
-        instance = TestSerializerModel.objects.last()
-        self.assertInstance(instance, data)
-        self.assertNotEqual(instance.generated, "fixed")
-
     def test_update(self):
         """We update a model through the serializer and check that the values were
         correctly updated in DB."""
@@ -139,3 +115,27 @@ def test_error_slug(self):
         self.assertFalse(serializer.is_valid())
         self.assertEqual(len(serializer.errors), 1)
         self.assertTrue("slug" in serializer.errors)
+
+    def test_write_only(self):
+        """We create a model on DB and then check the serialized data without the
+        write only field."""
+        data = self.create_random_data()
+        instance = TestSerializerModel.objects.create(**data)
+        serializer = TestModelSerializer(instance)
+        serialized_data = serializer.data
+        self.assertInstance(instance, serialized_data)
+        self.assertFalse("password" in serialized_data)
+
+    def test_read_only(self):
+        """We create a model through the serializer and check that it was created
+        correctly skipping the write only field."""
+        data = self.create_random_data()
+        data["generated"] = "fixed"
+        serializer = TestModelSerializer(data=data)
+        self.assertTrue(serializer.is_valid())
+        serializer.save()
+
+        del data["generated"]
+        instance = TestSerializerModel.objects.last()
+        self.assertInstance(instance, data)
+        self.assertNotEqual(instance.generated, "fixed")

From 3f3c332b7c1cceb4298e84627c736621d5a02973 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Mat=C3=ADas=20Saguir?= <mativs@gmail.com>
Date: Mon, 27 Jan 2025 17:32:30 -0300
Subject: [PATCH 06/14] add more asserts on test

---
 .../custom_rest_framework/tests.py                     | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/profile-specific-challenges/backend/custom_rest_framework/custom_rest_framework/tests.py b/profile-specific-challenges/backend/custom_rest_framework/custom_rest_framework/tests.py
index c842cef4..43e45c8f 100644
--- a/profile-specific-challenges/backend/custom_rest_framework/custom_rest_framework/tests.py
+++ b/profile-specific-challenges/backend/custom_rest_framework/custom_rest_framework/tests.py
@@ -49,12 +49,20 @@ def assertInstance(self, instance: Any, data: dict):
             assert hasattr(instance, k)
             assert getattr(instance, k) == v
 
+    def assertDictionary(self, source: dict, data: dict, exclude: list = dict()):
+        """Assert that all the values in the data should exists in the source."""
+        for k, v in data.items():
+            if k not in exclude:
+                assert source.get(k) is not None, f"{k} should be in source"
+                assert source.get(k) == v, f"{source.get(k)} != {v}"
+
     def test_read(self):
         """We create a model on DB and then check the serialized data is correct."""
         data = self.create_random_data()
         instance = TestSerializerModel.objects.create(**data)
         serializer = TestModelSerializer(instance)
         self.assertInstance(instance, serializer.data)
+        self.assertDictionary(serializer.data, data, ["password"])
 
     def test_create(self):
         """We create a model through the serializer and check that it was created
@@ -125,6 +133,7 @@ def test_write_only(self):
         serialized_data = serializer.data
         self.assertInstance(instance, serialized_data)
         self.assertFalse("password" in serialized_data)
+        self.assertDictionary(serializer.data, data, ["password"])
 
     def test_read_only(self):
         """We create a model through the serializer and check that it was created
@@ -139,3 +148,4 @@ def test_read_only(self):
         instance = TestSerializerModel.objects.last()
         self.assertInstance(instance, data)
         self.assertNotEqual(instance.generated, "fixed")
+        self.assertDictionary(serializer.data, data, ["password"])

From 0af812b047d54cf14c08ec15f1748909ea1256b4 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Mat=C3=ADas=20Saguir?= <mativs@gmail.com>
Date: Mon, 27 Jan 2025 17:43:44 -0300
Subject: [PATCH 07/14] improve tests

---
 .../custom_rest_framework/tests.py            | 22 +++++++++++--------
 1 file changed, 13 insertions(+), 9 deletions(-)

diff --git a/profile-specific-challenges/backend/custom_rest_framework/custom_rest_framework/tests.py b/profile-specific-challenges/backend/custom_rest_framework/custom_rest_framework/tests.py
index 43e45c8f..3a886ab3 100644
--- a/profile-specific-challenges/backend/custom_rest_framework/custom_rest_framework/tests.py
+++ b/profile-specific-challenges/backend/custom_rest_framework/custom_rest_framework/tests.py
@@ -42,25 +42,28 @@ def create_random_data(self) -> dict:
             password=str(random.randint(100000, 999999)),
         )
 
-    def assertInstance(self, instance: Any, data: dict):
+    def assertInstance(self, instance: Any, data: dict, eclude: list = list()):
         """Assert that all the values in the dictionary exists as a property in the
         instance."""
-        for k, v in data.items():
-            assert hasattr(instance, k)
-            assert getattr(instance, k) == v
+        if data and instance:
+            for k, v in data.items():
+                assert hasattr(instance, k)
+                assert getattr(instance, k) == v
 
-    def assertDictionary(self, source: dict, data: dict, exclude: list = dict()):
+    def assertDictionary(self, source: dict, data: dict, exclude: list = list()):
         """Assert that all the values in the data should exists in the source."""
-        for k, v in data.items():
-            if k not in exclude:
-                assert source.get(k) is not None, f"{k} should be in source"
-                assert source.get(k) == v, f"{source.get(k)} != {v}"
+        if data and source:
+            for k, v in data.items():
+                if k not in exclude:
+                    assert source.get(k) is not None, f"{k} should be in source"
+                    assert source.get(k) == v, f"{source.get(k)} != {v}"
 
     def test_read(self):
         """We create a model on DB and then check the serialized data is correct."""
         data = self.create_random_data()
         instance = TestSerializerModel.objects.create(**data)
         serializer = TestModelSerializer(instance)
+        self.assertIsNotNone(serializer.data)
         self.assertInstance(instance, serializer.data)
         self.assertDictionary(serializer.data, data, ["password"])
 
@@ -132,6 +135,7 @@ def test_write_only(self):
         serializer = TestModelSerializer(instance)
         serialized_data = serializer.data
         self.assertInstance(instance, serialized_data)
+        self.assertIsNotNone(serialized_data)
         self.assertFalse("password" in serialized_data)
         self.assertDictionary(serializer.data, data, ["password"])
 

From 2b19f75ef4f39fea493ff1f52ca394106ef0204e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Mat=C3=ADas=20Saguir?= <mativs@gmail.com>
Date: Tue, 28 Jan 2025 10:59:07 -0300
Subject: [PATCH 08/14] Improve tests

---
 .../custom_rest_framework/tests.py            | 82 ++++++++++++-------
 1 file changed, 52 insertions(+), 30 deletions(-)

diff --git a/profile-specific-challenges/backend/custom_rest_framework/custom_rest_framework/tests.py b/profile-specific-challenges/backend/custom_rest_framework/custom_rest_framework/tests.py
index 3a886ab3..e2f7b868 100644
--- a/profile-specific-challenges/backend/custom_rest_framework/custom_rest_framework/tests.py
+++ b/profile-specific-challenges/backend/custom_rest_framework/custom_rest_framework/tests.py
@@ -42,32 +42,50 @@ def create_random_data(self) -> dict:
             password=str(random.randint(100000, 999999)),
         )
 
-    def assertInstance(self, instance: Any, data: dict, eclude: list = list()):
+    def assertInstance(self, instance: Any, data: dict, exclude: list = list()):
         """Assert that all the values in the dictionary exists as a property in the
         instance."""
         if data and instance:
-            for k, v in data.items():
-                assert hasattr(instance, k)
-                assert getattr(instance, k) == v
-
-    def assertDictionary(self, source: dict, data: dict, exclude: list = list()):
-        """Assert that all the values in the data should exists in the source."""
-        if data and source:
             for k, v in data.items():
                 if k not in exclude:
-                    assert source.get(k) is not None, f"{k} should be in source"
-                    assert source.get(k) == v, f"{source.get(k)} != {v}"
-
-    def test_read(self):
+                    assert hasattr(instance, k), (
+                        f"Property {k} should exist in instance"
+                    )
+                    assert getattr(instance, k) == v, (
+                        f"Property value '{v}' should be equals to instance value"
+                    )
+
+    def assertEqualDictionary(self, left: dict, right: dict, exclude: list = list()):
+        """Assert that all the values in the right should exists in the left."""
+        if right and left:
+            for k, v in right.items():
+                if k not in exclude:
+                    assert left.get(k) is not None, (
+                        f"Property {k} should be in left dictionary"
+                    )
+                    assert left.get(k) == v, (
+                        f"Property value '{left.get(k)}' should be equals to right value {v}"
+                    )
+
+            for k, v in left.items():
+                if k not in exclude:
+                    assert right.get(k) is not None, (
+                        f"Property {k} should be in right dictionary"
+                    )
+                    assert right.get(k) == v, (
+                        f"Property value '{left.get(k)}' should be equals to right value {v}"
+                    )
+
+    def test_1_read(self):
         """We create a model on DB and then check the serialized data is correct."""
         data = self.create_random_data()
         instance = TestSerializerModel.objects.create(**data)
         serializer = TestModelSerializer(instance)
-        self.assertIsNotNone(serializer.data)
+        self.assertIsNotNone(serializer.data, "Serializer should return some data")
         self.assertInstance(instance, serializer.data)
-        self.assertDictionary(serializer.data, data, ["password"])
+        self.assertEqualDictionary(serializer.data, data, ["password", "generated"])
 
-    def test_create(self):
+    def test_2_create(self):
         """We create a model through the serializer and check that it was created
         correctly in DB."""
         data = self.create_random_data()
@@ -77,7 +95,7 @@ def test_create(self):
         instance = TestSerializerModel.objects.last()
         self.assertInstance(instance, data)
 
-    def test_update(self):
+    def test_3_update(self):
         """We update a model through the serializer and check that the values were
         correctly updated in DB."""
         data = self.create_random_data()
@@ -91,65 +109,69 @@ def test_update(self):
         new_instance = TestSerializerModel.objects.get(id=instance.id)
         self.assertInstance(new_instance, new_data)
 
-    def test_error_int(self):
+    def test_4_error_int(self):
         """We force an error on creation on the number field."""
         data = self.create_random_data()
         data["number"] = "15.5"
         serializer = TestModelSerializer(data=data)
         self.assertFalse(serializer.is_valid())
+        self.assertIsNotNone(serializer.errors)
         self.assertEqual(len(serializer.errors), 1)
         self.assertTrue("number" in serializer.errors)
 
-    def test_error_bool(self):
+    def test_5_error_bool(self):
         """We force an error on creation on the bool field."""
         data = self.create_random_data()
         data["is_something"] = "jojo"
         serializer = TestModelSerializer(data=data)
         self.assertFalse(serializer.is_valid())
+        self.assertIsNotNone(serializer.errors)
         self.assertEqual(len(serializer.errors), 1)
         self.assertTrue("is_something" in serializer.errors)
 
-    def test_error_email(self):
+    def test_6_error_email(self):
         """We force an error on creation on the email field."""
         data = self.create_random_data()
         data["email"] = "not_an_email"
         serializer = TestModelSerializer(data=data)
         self.assertFalse(serializer.is_valid())
+        self.assertIsNotNone(serializer.errors)
         self.assertEqual(len(serializer.errors), 1)
         self.assertTrue("email" in serializer.errors)
 
-    def test_error_slug(self):
+    def test_7_error_slug(self):
         """We force an error on creation on the slug field."""
         data = self.create_random_data()
         data["slug"] = "not_an_slug./$"
         serializer = TestModelSerializer(data=data)
         self.assertFalse(serializer.is_valid())
+        self.assertIsNotNone(serializer.errors)
         self.assertEqual(len(serializer.errors), 1)
         self.assertTrue("slug" in serializer.errors)
 
-    def test_write_only(self):
+    def test_8_write_only(self):
         """We create a model on DB and then check the serialized data without the
         write only field."""
         data = self.create_random_data()
         instance = TestSerializerModel.objects.create(**data)
         serializer = TestModelSerializer(instance)
         serialized_data = serializer.data
-        self.assertInstance(instance, serialized_data)
         self.assertIsNotNone(serialized_data)
+        self.assertInstance(instance, serialized_data)
         self.assertFalse("password" in serialized_data)
-        self.assertDictionary(serializer.data, data, ["password"])
+        self.assertEqualDictionary(serializer.data, data, ["password", "generated"])
 
-    def test_read_only(self):
+    def test_9_read_only(self):
         """We create a model through the serializer and check that it was created
         correctly skipping the write only field."""
         data = self.create_random_data()
-        data["generated"] = "fixed"
+        data["generated"] = "fixed"  # we write a wrong value in a generated field
         serializer = TestModelSerializer(data=data)
         self.assertTrue(serializer.is_valid())
         serializer.save()
-
-        del data["generated"]
         instance = TestSerializerModel.objects.last()
-        self.assertInstance(instance, data)
-        self.assertNotEqual(instance.generated, "fixed")
-        self.assertDictionary(serializer.data, data, ["password"])
+        self.assertIsNotNone(serializer.data)
+        self.assertInstance(instance, data, ["generated"])
+        self.assertNotEqual(instance.generated, data["generated"])
+        self.assertEqual(instance.generated, f"{data['slug']}:{str(data['number'])}")
+        self.assertEqualDictionary(serializer.data, data, ["password", "generated"])

From 91d4f71e6c2098b15e4b8f060ead643aea663893 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Mat=C3=ADas=20Saguir?= <mativs@gmail.com>
Date: Tue, 28 Jan 2025 11:56:42 -0300
Subject: [PATCH 09/14] ordering of tests

---
 .../custom_rest_framework/tests.py            | 19 +++++++++----------
 1 file changed, 9 insertions(+), 10 deletions(-)

diff --git a/profile-specific-challenges/backend/custom_rest_framework/custom_rest_framework/tests.py b/profile-specific-challenges/backend/custom_rest_framework/custom_rest_framework/tests.py
index e2f7b868..f56803ae 100644
--- a/profile-specific-challenges/backend/custom_rest_framework/custom_rest_framework/tests.py
+++ b/profile-specific-challenges/backend/custom_rest_framework/custom_rest_framework/tests.py
@@ -129,25 +129,25 @@ def test_5_error_bool(self):
         self.assertEqual(len(serializer.errors), 1)
         self.assertTrue("is_something" in serializer.errors)
 
-    def test_6_error_email(self):
-        """We force an error on creation on the email field."""
+    def test_6_error_slug(self):
+        """We force an error on creation on the slug field."""
         data = self.create_random_data()
-        data["email"] = "not_an_email"
+        data["slug"] = "not_an_slug./$"
         serializer = TestModelSerializer(data=data)
         self.assertFalse(serializer.is_valid())
         self.assertIsNotNone(serializer.errors)
         self.assertEqual(len(serializer.errors), 1)
-        self.assertTrue("email" in serializer.errors)
+        self.assertTrue("slug" in serializer.errors)
 
-    def test_7_error_slug(self):
-        """We force an error on creation on the slug field."""
+    def test_7_error_email(self):
+        """We force an error on creation on the email field."""
         data = self.create_random_data()
-        data["slug"] = "not_an_slug./$"
+        data["email"] = "not_an_email"
         serializer = TestModelSerializer(data=data)
         self.assertFalse(serializer.is_valid())
         self.assertIsNotNone(serializer.errors)
         self.assertEqual(len(serializer.errors), 1)
-        self.assertTrue("slug" in serializer.errors)
+        self.assertTrue("email" in serializer.errors)
 
     def test_8_write_only(self):
         """We create a model on DB and then check the serialized data without the
@@ -163,14 +163,13 @@ def test_8_write_only(self):
 
     def test_9_read_only(self):
         """We create a model through the serializer and check that it was created
-        correctly skipping the write only field."""
+        correctly skipping the read only field."""
         data = self.create_random_data()
         data["generated"] = "fixed"  # we write a wrong value in a generated field
         serializer = TestModelSerializer(data=data)
         self.assertTrue(serializer.is_valid())
         serializer.save()
         instance = TestSerializerModel.objects.last()
-        self.assertIsNotNone(serializer.data)
         self.assertInstance(instance, data, ["generated"])
         self.assertNotEqual(instance.generated, data["generated"])
         self.assertEqual(instance.generated, f"{data['slug']}:{str(data['number'])}")

From 53166a2ba01c4b489ce830904ac4d5b39d18a472 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Mat=C3=ADas=20Saguir?= <mativs@gmail.com>
Date: Tue, 28 Jan 2025 14:09:11 -0300
Subject: [PATCH 10/14] improve challenge description

---
 .../backend/custom_rest_framework/challenge.md       | 12 ++++++++++--
 1 file changed, 10 insertions(+), 2 deletions(-)

diff --git a/profile-specific-challenges/backend/custom_rest_framework/challenge.md b/profile-specific-challenges/backend/custom_rest_framework/challenge.md
index 9b878b16..20e22677 100644
--- a/profile-specific-challenges/backend/custom_rest_framework/challenge.md
+++ b/profile-specific-challenges/backend/custom_rest_framework/challenge.md
@@ -5,8 +5,16 @@ Your task is to implement a custom version of the `ModelSerializer` class, origi
 1. The serializer should automatically define its fields based on the `fields` parameter in the `Meta` class. 
 2. Implement support for the following field types: `CharField`, `IntegerField`, `BooleanField`, `FloatField`, `EmailField` and `SlugField`
 3. Implement the `read_only` and `write_only` parameters for the fields.
-4. Implement the following methods in the serializer: `read`, `create` and `write`.
-5. Implement proper validations for: `IntegerField`, `BooleanField`, `EmailField`, `SlugField`
+4. Implement proper validations for: `IntegerField`, `BooleanField`, `EmailField`, `SlugField`
+5. Implement the following properties and methods:
+    - .data - Returns the outgoing primitive representation.
+    - .is_valid() - Deserializes and validates incoming data.
+    - .validated_data - Returns the validated incoming data.
+    - .errors - Returns any errors during validation.
+    - .save() - Persists the validated data into an object instance.
+    - .to_representation(instance) - for read operations.
+    - .to_internal_value(data) - for write operations.
+    - .create(validated_data) and .update(instance, validated_data) - to support saving instances.
 
 The app `custom_rest_framework` has already been created with a dummy model named `TestSerializerModel` with the necessary fields. Additionally, a test file has been pre-configured, containing all the necessary test cases.
 

From 2e7d9d8347353b24dcd64ff10201502f6b26575e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Mat=C3=ADas=20Saguir?= <mativs@gmail.com>
Date: Tue, 28 Jan 2025 14:09:28 -0300
Subject: [PATCH 11/14] add more assertion on tests

---
 .../custom_rest_framework/custom_rest_framework/tests.py        | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/profile-specific-challenges/backend/custom_rest_framework/custom_rest_framework/tests.py b/profile-specific-challenges/backend/custom_rest_framework/custom_rest_framework/tests.py
index f56803ae..2213fee4 100644
--- a/profile-specific-challenges/backend/custom_rest_framework/custom_rest_framework/tests.py
+++ b/profile-specific-challenges/backend/custom_rest_framework/custom_rest_framework/tests.py
@@ -57,7 +57,7 @@ def assertInstance(self, instance: Any, data: dict, exclude: list = list()):
 
     def assertEqualDictionary(self, left: dict, right: dict, exclude: list = list()):
         """Assert that all the values in the right should exists in the left."""
-        if right and left:
+        if right is not None and left is not None:
             for k, v in right.items():
                 if k not in exclude:
                     assert left.get(k) is not None, (

From 6d0cd6c9d082837b681605bd99701a705e438dcc Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Mat=C3=ADas=20Saguir?= <mativs@kamipay.io>
Date: Mon, 4 May 2026 22:20:05 -0300
Subject: [PATCH 12/14] ir: base python and strings

---
 technical-fundamentals/python/README.md       |  42 +++++++++
 .../conftest.cpython-314-pytest-9.0.3.pyc     | Bin 0 -> 3158 bytes
 .../__pycache__/conftest.cpython-314.pyc      | Bin 0 -> 4137 bytes
 .../python/coding/__init__.py                 |   0
 .../__pycache__/__init__.cpython-314.pyc      | Bin 0 -> 191 bytes
 .../python/coding/problems/01_is_unique.py    |  12 +++
 .../coding/problems/02_check_permutations.py  |  18 ++++
 .../python/coding/problems/03_urlify.py       |  14 +++
 .../problems/04_palindrome_permutation.py     |  26 ++++++
 .../python/coding/problems/05_one_away.py     |  48 ++++++++++
 .../coding/problems/06_string_compression.py  |  27 ++++++
 .../coding/problems/07_rotate_matrix.py       |  27 ++++++
 .../python/coding/problems/08_zero_matrix.py  |  37 ++++++++
 .../coding/problems/09_string_rotation.py     |  11 +++
 .../python/coding/problems/10_linked_list.py  |  39 ++++++++
 .../python/coding/problems/11_remove_dups.py  |  20 ++++
 .../python/coding/problems/12_kth_to_last.py  |  17 ++++
 .../coding/problems/13_delete_middle_node.py  |  23 +++++
 .../python/coding/problems/14_partition.py    |  24 +++++
 .../python/coding/problems/15_sum_lists.py    |  25 +++++
 .../problems/16_sum_lists_forward_order.py    |  22 +++++
 .../python/coding/problems/17_palindrome.py   |  17 ++++
 .../python/coding/problems/18_intersection.py |  22 +++++
 .../coding/problems/19_loop_detection.py      |  26 ++++++
 .../python/coding/problems/21_three_stacks.py |  20 ++++
 .../python/coding/problems/22_stack_min.py    |  22 +++++
 .../coding/problems/23_stack_of_plates.py     |  24 +++++
 .../coding/problems/24_queue_via_stacks.py    |  23 +++++
 .../python/coding/problems/25_sort_stack.py   |  26 ++++++
 .../coding/problems/26_animal_shelter.py      |  34 +++++++
 .../python/coding/problems/30_trees.py        |  36 ++++++++
 .../problems/31_has_route_between_nodes.py    |  16 ++++
 .../python/coding/problems/32_minimal_tree.py |  33 +++++++
 .../coding/problems/33_list_of_depths.py      |  30 ++++++
 .../coding/problems/34_check_balanced.py      |  25 +++++
 .../python/coding/problems/35_validate_bst.py |  23 +++++
 .../python/coding/problems/36_successor.py    |  26 ++++++
 .../python/coding/problems/37_build_order.py  |  19 ++++
 .../problems/38_first_common_ancestor.py      |  29 ++++++
 .../coding/problems/39_bst_sequences.py       |  32 +++++++
 .../python/coding/problems/41_triple_steps.py |   8 ++
 .../coding/problems/42_robot_in_a_grid.py     |  14 +++
 .../python/coding/problems/43_magic_index.py  |  16 ++++
 .../python/coding/problems/44_power_set.py    |  12 +++
 .../coding/problems/45_recursive_multiply.py  |   8 ++
 .../coding/problems/46_towers_of_hanoi.py     |  20 ++++
 .../problems/47_permutations_with_dups.py     |  16 ++++
 .../python/coding/problems/48_coin_change.py  |  19 ++++
 .../python/coding/problems/__init__.py        |   0
 .../__pycache__/01_is_unique.cpython-314.pyc  | Bin 0 -> 596 bytes
 .../02_check_permutations.cpython-314.pyc     | Bin 0 -> 947 bytes
 .../__pycache__/03_urlify.cpython-314.pyc     | Bin 0 -> 627 bytes
 .../04_palindrome_permutation.cpython-314.pyc | Bin 0 -> 795 bytes
 .../__pycache__/05_one_away.cpython-314.pyc   | Bin 0 -> 1207 bytes
 .../06_string_compression.cpython-314.pyc     | Bin 0 -> 1034 bytes
 .../07_rotate_matrix.cpython-314.pyc          | Bin 0 -> 1411 bytes
 .../08_zero_matrix.cpython-314.pyc            | Bin 0 -> 1678 bytes
 .../09_string_rotation.cpython-314.pyc        | Bin 0 -> 644 bytes
 .../11_remove_dups.cpython-314.pyc            | Bin 0 -> 1318 bytes
 .../12_kth_to_last.cpython-314.pyc            | Bin 0 -> 1337 bytes
 .../13_delete_middle_node.cpython-314.pyc     | Bin 0 -> 1358 bytes
 .../__pycache__/14_partition.cpython-314.pyc  | Bin 0 -> 1325 bytes
 .../__pycache__/15_sum_lists.cpython-314.pyc  | Bin 0 -> 1230 bytes
 ...16_sum_lists_forward_order.cpython-314.pyc | Bin 0 -> 1258 bytes
 .../__pycache__/17_palindrome.cpython-314.pyc | Bin 0 -> 1310 bytes
 .../18_intersection.cpython-314.pyc           | Bin 0 -> 1336 bytes
 .../19_loop_detection.cpython-314.pyc         | Bin 0 -> 1307 bytes
 .../21_three_stacks.cpython-314.pyc           | Bin 0 -> 1935 bytes
 .../__pycache__/22_stack_min.cpython-314.pyc  | Bin 0 -> 1616 bytes
 .../23_stack_of_plates.cpython-314.pyc        | Bin 0 -> 1566 bytes
 .../24_queue_via_stacks.cpython-314.pyc       | Bin 0 -> 1929 bytes
 .../__pycache__/25_sort_stack.cpython-314.pyc | Bin 0 -> 1923 bytes
 .../26_animal_shelter.cpython-314.pyc         | Bin 0 -> 2449 bytes
 .../__pycache__/30_trees.cpython-314.pyc      | Bin 0 -> 1958 bytes
 ...31_has_route_between_nodes.cpython-314.pyc | Bin 0 -> 1307 bytes
 .../32_minimal_tree.cpython-314.pyc           | Bin 0 -> 1415 bytes
 .../33_list_of_depths.cpython-314.pyc         | Bin 0 -> 1985 bytes
 .../34_check_balanced.cpython-314.pyc         | Bin 0 -> 1393 bytes
 .../35_validate_bst.cpython-314.pyc           | Bin 0 -> 1389 bytes
 .../__pycache__/36_successor.cpython-314.pyc  | Bin 0 -> 1446 bytes
 .../37_build_order.cpython-314.pyc            | Bin 0 -> 766 bytes
 .../38_first_common_ancestor.cpython-314.pyc  | Bin 0 -> 1463 bytes
 .../39_bst_sequences.cpython-314.pyc          | Bin 0 -> 1404 bytes
 .../41_triple_steps.cpython-314.pyc           | Bin 0 -> 500 bytes
 .../42_robot_in_a_grid.cpython-314.pyc        | Bin 0 -> 769 bytes
 .../43_magic_index.cpython-314.pyc            | Bin 0 -> 973 bytes
 .../__pycache__/44_power_set.cpython-314.pyc  | Bin 0 -> 621 bytes
 .../45_recursive_multiply.cpython-314.pyc     | Bin 0 -> 541 bytes
 .../46_towers_of_hanoi.cpython-314.pyc        | Bin 0 -> 671 bytes
 .../47_permutations_with_dups.cpython-314.pyc | Bin 0 -> 899 bytes
 .../48_coin_change.cpython-314.pyc            | Bin 0 -> 610 bytes
 .../__pycache__/__init__.cpython-314.pyc      | Bin 0 -> 200 bytes
 .../python/coding/problems/tests/__init__.py  |   0
 .../__pycache__/__init__.cpython-314.pyc      | Bin 0 -> 206 bytes
 .../conftest.cpython-314-pytest-9.0.3.pyc     | Bin 0 -> 1273 bytes
 .../coding/problems/tests/lists/__init__.py   |   0
 .../__pycache__/__init__.cpython-314.pyc      | Bin 0 -> 212 bytes
 ...1_remove_dups.cpython-314-pytest-9.0.3.pyc | Bin 0 -> 8120 bytes
 ...2_kth_to_last.cpython-314-pytest-9.0.3.pyc | Bin 0 -> 6787 bytes
 ...e_middle_node.cpython-314-pytest-9.0.3.pyc | Bin 0 -> 10016 bytes
 ..._14_partition.cpython-314-pytest-9.0.3.pyc | Bin 0 -> 10295 bytes
 ..._15_sum_lists.cpython-314-pytest-9.0.3.pyc | Bin 0 -> 7508 bytes
 ...forward_order.cpython-314-pytest-9.0.3.pyc | Bin 0 -> 14258 bytes
 ...17_palindrome.cpython-314-pytest-9.0.3.pyc | Bin 0 -> 7034 bytes
 ..._intersection.cpython-314-pytest-9.0.3.pyc | Bin 0 -> 8103 bytes
 ...oop_detection.cpython-314-pytest-9.0.3.pyc | Bin 0 -> 7661 bytes
 .../tests/lists/test_11_remove_dups.py        |  65 +++++++++++++
 .../tests/lists/test_12_kth_to_last.py        |  41 +++++++++
 .../tests/lists/test_13_delete_middle_node.py |  68 ++++++++++++++
 .../problems/tests/lists/test_14_partition.py |  62 +++++++++++++
 .../problems/tests/lists/test_15_sum_lists.py |  47 ++++++++++
 .../lists/test_16_sum_lists_forward_order.py  |  68 ++++++++++++++
 .../tests/lists/test_17_palindrome.py         |  40 ++++++++
 .../tests/lists/test_18_intersection.py       |  42 +++++++++
 .../tests/lists/test_19_loop_detection.py     |  41 +++++++++
 .../problems/tests/recursion/__init__.py      |   0
 .../__pycache__/__init__.cpython-314.pyc      | Bin 0 -> 216 bytes
 ..._triple_steps.cpython-314-pytest-9.0.3.pyc | Bin 0 -> 7537 bytes
 ...bot_in_a_grid.cpython-314-pytest-9.0.3.pyc | Bin 0 -> 5059 bytes
 ...3_magic_index.cpython-314-pytest-9.0.3.pyc | Bin 0 -> 5086 bytes
 ..._44_power_set.cpython-314-pytest-9.0.3.pyc | Bin 0 -> 7076 bytes
 ...sive_multiply.cpython-314-pytest-9.0.3.pyc | Bin 0 -> 5587 bytes
 ...wers_of_hanoi.cpython-314-pytest-9.0.3.pyc | Bin 0 -> 4022 bytes
 ...ons_with_dups.cpython-314-pytest-9.0.3.pyc | Bin 0 -> 5159 bytes
 ...8_coin_change.cpython-314-pytest-9.0.3.pyc | Bin 0 -> 5846 bytes
 .../tests/recursion/test_41_triple_steps.py   |  31 +++++++
 .../recursion/test_42_robot_in_a_grid.py      |  46 +++++++++
 .../tests/recursion/test_43_magic_index.py    |  30 ++++++
 .../tests/recursion/test_44_power_set.py      |  39 ++++++++
 .../recursion/test_45_recursive_multiply.py   |  25 +++++
 .../recursion/test_46_towers_of_hanoi.py      |  23 +++++
 .../test_47_permutations_with_dups.py         |  37 ++++++++
 .../tests/recursion/test_48_coin_change.py    |  28 ++++++
 .../coding/problems/tests/stacks/__init__.py  |   0
 .../__pycache__/__init__.cpython-314.pyc      | Bin 0 -> 213 bytes
 ..._three_stacks.cpython-314-pytest-9.0.3.pyc | Bin 0 -> 18237 bytes
 ..._22_stack_min.cpython-314-pytest-9.0.3.pyc | Bin 0 -> 19252 bytes
 ...ack_of_plates.cpython-314-pytest-9.0.3.pyc | Bin 0 -> 14650 bytes
 ...ue_via_stacks.cpython-314-pytest-9.0.3.pyc | Bin 0 -> 14750 bytes
 ...25_sort_stack.cpython-314-pytest-9.0.3.pyc | Bin 0 -> 14076 bytes
 ...nimal_shelter.cpython-314-pytest-9.0.3.pyc | Bin 0 -> 8150 bytes
 .../tests/stacks/test_21_three_stacks.py      |  66 +++++++++++++
 .../tests/stacks/test_22_stack_min.py         |  50 ++++++++++
 .../tests/stacks/test_23_stack_of_plates.py   |  54 +++++++++++
 .../tests/stacks/test_24_queue_via_stacks.py  |  50 ++++++++++
 .../tests/stacks/test_25_sort_stack.py        |  54 +++++++++++
 .../tests/stacks/test_26_animal_shelter.py    |  35 +++++++
 .../coding/problems/tests/strings/__init__.py |   0
 .../__pycache__/__init__.cpython-314.pyc      | Bin 0 -> 214 bytes
 ..._01_is_unique.cpython-314-pytest-9.0.3.pyc | Bin 0 -> 14455 bytes
 ..._permutations.cpython-314-pytest-9.0.3.pyc | Bin 0 -> 9819 bytes
 ...est_03_urlify.cpython-314-pytest-9.0.3.pyc | Bin 0 -> 7977 bytes
 ...e_permutation.cpython-314-pytest-9.0.3.pyc | Bin 0 -> 10854 bytes
 ...t_05_one_away.cpython-314-pytest-9.0.3.pyc | Bin 0 -> 12014 bytes
 ...g_compression.cpython-314-pytest-9.0.3.pyc | Bin 0 -> 7574 bytes
 ...rotate_matrix.cpython-314-pytest-9.0.3.pyc | Bin 0 -> 5603 bytes
 ...8_zero_matrix.cpython-314-pytest-9.0.3.pyc | Bin 0 -> 5257 bytes
 ...ring_rotation.cpython-314-pytest-9.0.3.pyc | Bin 0 -> 4140 bytes
 .../tests/strings/test_01_is_unique.py        |  52 +++++++++++
 .../strings/test_02_check_permutations.py     |  45 +++++++++
 .../problems/tests/strings/test_03_urlify.py  |  45 +++++++++
 .../strings/test_04_palindrome_permutation.py |  57 ++++++++++++
 .../tests/strings/test_05_one_away.py         |  58 ++++++++++++
 .../strings/test_06_string_compression.py     |  41 +++++++++
 .../tests/strings/test_07_rotate_matrix.py    |  63 +++++++++++++
 .../tests/strings/test_08_zero_matrix.py      |  61 ++++++++++++
 .../tests/strings/test_09_string_rotation.py  |  29 ++++++
 .../coding/problems/tests/trees/__init__.py   |   0
 .../__pycache__/__init__.cpython-314.pyc      | Bin 0 -> 212 bytes
 ...test_30_trees.cpython-314-pytest-9.0.3.pyc | Bin 0 -> 3927 bytes
 ...between_nodes.cpython-314-pytest-9.0.3.pyc | Bin 0 -> 9672 bytes
 ..._minimal_tree.cpython-314-pytest-9.0.3.pyc | Bin 0 -> 7622 bytes
 ...ist_of_depths.cpython-314-pytest-9.0.3.pyc | Bin 0 -> 8095 bytes
 ...heck_balanced.cpython-314-pytest-9.0.3.pyc | Bin 0 -> 5214 bytes
 ..._validate_bst.cpython-314-pytest-9.0.3.pyc | Bin 0 -> 7633 bytes
 ..._36_successor.cpython-314-pytest-9.0.3.pyc | Bin 0 -> 9972 bytes
 ...7_build_order.cpython-314-pytest-9.0.3.pyc | Bin 0 -> 5798 bytes
 ...mmon_ancestor.cpython-314-pytest-9.0.3.pyc | Bin 0 -> 6196 bytes
 ...bst_sequences.cpython-314-pytest-9.0.3.pyc | Bin 0 -> 5623 bytes
 .../problems/tests/trees/test_30_trees.py     |  40 ++++++++
 .../trees/test_31_has_route_between_nodes.py  |  40 ++++++++
 .../tests/trees/test_32_minimal_tree.py       |  48 ++++++++++
 .../tests/trees/test_33_list_of_depths.py     |  47 ++++++++++
 .../tests/trees/test_34_check_balanced.py     |  35 +++++++
 .../tests/trees/test_35_validate_bst.py       |  44 +++++++++
 .../problems/tests/trees/test_36_successor.py |  38 ++++++++
 .../tests/trees/test_37_build_order.py        |  39 ++++++++
 .../trees/test_38_first_common_ancestor.py    |  28 ++++++
 .../tests/trees/test_39_bst_sequences.py      |  36 ++++++++
 .../problems/tools/add_js_docstrings.py       |  61 ++++++++++++
 .../coding/problems/tools/fix_docstrings.py   |  87 ++++++++++++++++++
 .../python/coding/problems/utils/__init__.py  |   0
 .../__pycache__/__init__.cpython-314.pyc      | Bin 0 -> 206 bytes
 .../utils/__pycache__/strings.cpython-314.pyc | Bin 0 -> 1912 bytes
 .../python/coding/problems/utils/strings.py   |  27 ++++++
 technical-fundamentals/python/conftest.py     |  50 ++++++++++
 technical-fundamentals/python/pytest.ini      |   5 +
 .../python/requirements.txt                   |   1 +
 198 files changed, 3147 insertions(+)
 create mode 100644 technical-fundamentals/python/README.md
 create mode 100644 technical-fundamentals/python/__pycache__/conftest.cpython-314-pytest-9.0.3.pyc
 create mode 100644 technical-fundamentals/python/__pycache__/conftest.cpython-314.pyc
 create mode 100644 technical-fundamentals/python/coding/__init__.py
 create mode 100644 technical-fundamentals/python/coding/__pycache__/__init__.cpython-314.pyc
 create mode 100644 technical-fundamentals/python/coding/problems/01_is_unique.py
 create mode 100644 technical-fundamentals/python/coding/problems/02_check_permutations.py
 create mode 100644 technical-fundamentals/python/coding/problems/03_urlify.py
 create mode 100644 technical-fundamentals/python/coding/problems/04_palindrome_permutation.py
 create mode 100644 technical-fundamentals/python/coding/problems/05_one_away.py
 create mode 100644 technical-fundamentals/python/coding/problems/06_string_compression.py
 create mode 100644 technical-fundamentals/python/coding/problems/07_rotate_matrix.py
 create mode 100644 technical-fundamentals/python/coding/problems/08_zero_matrix.py
 create mode 100644 technical-fundamentals/python/coding/problems/09_string_rotation.py
 create mode 100644 technical-fundamentals/python/coding/problems/10_linked_list.py
 create mode 100644 technical-fundamentals/python/coding/problems/11_remove_dups.py
 create mode 100644 technical-fundamentals/python/coding/problems/12_kth_to_last.py
 create mode 100644 technical-fundamentals/python/coding/problems/13_delete_middle_node.py
 create mode 100644 technical-fundamentals/python/coding/problems/14_partition.py
 create mode 100644 technical-fundamentals/python/coding/problems/15_sum_lists.py
 create mode 100644 technical-fundamentals/python/coding/problems/16_sum_lists_forward_order.py
 create mode 100644 technical-fundamentals/python/coding/problems/17_palindrome.py
 create mode 100644 technical-fundamentals/python/coding/problems/18_intersection.py
 create mode 100644 technical-fundamentals/python/coding/problems/19_loop_detection.py
 create mode 100644 technical-fundamentals/python/coding/problems/21_three_stacks.py
 create mode 100644 technical-fundamentals/python/coding/problems/22_stack_min.py
 create mode 100644 technical-fundamentals/python/coding/problems/23_stack_of_plates.py
 create mode 100644 technical-fundamentals/python/coding/problems/24_queue_via_stacks.py
 create mode 100644 technical-fundamentals/python/coding/problems/25_sort_stack.py
 create mode 100644 technical-fundamentals/python/coding/problems/26_animal_shelter.py
 create mode 100644 technical-fundamentals/python/coding/problems/30_trees.py
 create mode 100644 technical-fundamentals/python/coding/problems/31_has_route_between_nodes.py
 create mode 100644 technical-fundamentals/python/coding/problems/32_minimal_tree.py
 create mode 100644 technical-fundamentals/python/coding/problems/33_list_of_depths.py
 create mode 100644 technical-fundamentals/python/coding/problems/34_check_balanced.py
 create mode 100644 technical-fundamentals/python/coding/problems/35_validate_bst.py
 create mode 100644 technical-fundamentals/python/coding/problems/36_successor.py
 create mode 100644 technical-fundamentals/python/coding/problems/37_build_order.py
 create mode 100644 technical-fundamentals/python/coding/problems/38_first_common_ancestor.py
 create mode 100644 technical-fundamentals/python/coding/problems/39_bst_sequences.py
 create mode 100644 technical-fundamentals/python/coding/problems/41_triple_steps.py
 create mode 100644 technical-fundamentals/python/coding/problems/42_robot_in_a_grid.py
 create mode 100644 technical-fundamentals/python/coding/problems/43_magic_index.py
 create mode 100644 technical-fundamentals/python/coding/problems/44_power_set.py
 create mode 100644 technical-fundamentals/python/coding/problems/45_recursive_multiply.py
 create mode 100644 technical-fundamentals/python/coding/problems/46_towers_of_hanoi.py
 create mode 100644 technical-fundamentals/python/coding/problems/47_permutations_with_dups.py
 create mode 100644 technical-fundamentals/python/coding/problems/48_coin_change.py
 create mode 100644 technical-fundamentals/python/coding/problems/__init__.py
 create mode 100644 technical-fundamentals/python/coding/problems/__pycache__/01_is_unique.cpython-314.pyc
 create mode 100644 technical-fundamentals/python/coding/problems/__pycache__/02_check_permutations.cpython-314.pyc
 create mode 100644 technical-fundamentals/python/coding/problems/__pycache__/03_urlify.cpython-314.pyc
 create mode 100644 technical-fundamentals/python/coding/problems/__pycache__/04_palindrome_permutation.cpython-314.pyc
 create mode 100644 technical-fundamentals/python/coding/problems/__pycache__/05_one_away.cpython-314.pyc
 create mode 100644 technical-fundamentals/python/coding/problems/__pycache__/06_string_compression.cpython-314.pyc
 create mode 100644 technical-fundamentals/python/coding/problems/__pycache__/07_rotate_matrix.cpython-314.pyc
 create mode 100644 technical-fundamentals/python/coding/problems/__pycache__/08_zero_matrix.cpython-314.pyc
 create mode 100644 technical-fundamentals/python/coding/problems/__pycache__/09_string_rotation.cpython-314.pyc
 create mode 100644 technical-fundamentals/python/coding/problems/__pycache__/11_remove_dups.cpython-314.pyc
 create mode 100644 technical-fundamentals/python/coding/problems/__pycache__/12_kth_to_last.cpython-314.pyc
 create mode 100644 technical-fundamentals/python/coding/problems/__pycache__/13_delete_middle_node.cpython-314.pyc
 create mode 100644 technical-fundamentals/python/coding/problems/__pycache__/14_partition.cpython-314.pyc
 create mode 100644 technical-fundamentals/python/coding/problems/__pycache__/15_sum_lists.cpython-314.pyc
 create mode 100644 technical-fundamentals/python/coding/problems/__pycache__/16_sum_lists_forward_order.cpython-314.pyc
 create mode 100644 technical-fundamentals/python/coding/problems/__pycache__/17_palindrome.cpython-314.pyc
 create mode 100644 technical-fundamentals/python/coding/problems/__pycache__/18_intersection.cpython-314.pyc
 create mode 100644 technical-fundamentals/python/coding/problems/__pycache__/19_loop_detection.cpython-314.pyc
 create mode 100644 technical-fundamentals/python/coding/problems/__pycache__/21_three_stacks.cpython-314.pyc
 create mode 100644 technical-fundamentals/python/coding/problems/__pycache__/22_stack_min.cpython-314.pyc
 create mode 100644 technical-fundamentals/python/coding/problems/__pycache__/23_stack_of_plates.cpython-314.pyc
 create mode 100644 technical-fundamentals/python/coding/problems/__pycache__/24_queue_via_stacks.cpython-314.pyc
 create mode 100644 technical-fundamentals/python/coding/problems/__pycache__/25_sort_stack.cpython-314.pyc
 create mode 100644 technical-fundamentals/python/coding/problems/__pycache__/26_animal_shelter.cpython-314.pyc
 create mode 100644 technical-fundamentals/python/coding/problems/__pycache__/30_trees.cpython-314.pyc
 create mode 100644 technical-fundamentals/python/coding/problems/__pycache__/31_has_route_between_nodes.cpython-314.pyc
 create mode 100644 technical-fundamentals/python/coding/problems/__pycache__/32_minimal_tree.cpython-314.pyc
 create mode 100644 technical-fundamentals/python/coding/problems/__pycache__/33_list_of_depths.cpython-314.pyc
 create mode 100644 technical-fundamentals/python/coding/problems/__pycache__/34_check_balanced.cpython-314.pyc
 create mode 100644 technical-fundamentals/python/coding/problems/__pycache__/35_validate_bst.cpython-314.pyc
 create mode 100644 technical-fundamentals/python/coding/problems/__pycache__/36_successor.cpython-314.pyc
 create mode 100644 technical-fundamentals/python/coding/problems/__pycache__/37_build_order.cpython-314.pyc
 create mode 100644 technical-fundamentals/python/coding/problems/__pycache__/38_first_common_ancestor.cpython-314.pyc
 create mode 100644 technical-fundamentals/python/coding/problems/__pycache__/39_bst_sequences.cpython-314.pyc
 create mode 100644 technical-fundamentals/python/coding/problems/__pycache__/41_triple_steps.cpython-314.pyc
 create mode 100644 technical-fundamentals/python/coding/problems/__pycache__/42_robot_in_a_grid.cpython-314.pyc
 create mode 100644 technical-fundamentals/python/coding/problems/__pycache__/43_magic_index.cpython-314.pyc
 create mode 100644 technical-fundamentals/python/coding/problems/__pycache__/44_power_set.cpython-314.pyc
 create mode 100644 technical-fundamentals/python/coding/problems/__pycache__/45_recursive_multiply.cpython-314.pyc
 create mode 100644 technical-fundamentals/python/coding/problems/__pycache__/46_towers_of_hanoi.cpython-314.pyc
 create mode 100644 technical-fundamentals/python/coding/problems/__pycache__/47_permutations_with_dups.cpython-314.pyc
 create mode 100644 technical-fundamentals/python/coding/problems/__pycache__/48_coin_change.cpython-314.pyc
 create mode 100644 technical-fundamentals/python/coding/problems/__pycache__/__init__.cpython-314.pyc
 create mode 100644 technical-fundamentals/python/coding/problems/tests/__init__.py
 create mode 100644 technical-fundamentals/python/coding/problems/tests/__pycache__/__init__.cpython-314.pyc
 create mode 100644 technical-fundamentals/python/coding/problems/tests/__pycache__/conftest.cpython-314-pytest-9.0.3.pyc
 create mode 100644 technical-fundamentals/python/coding/problems/tests/lists/__init__.py
 create mode 100644 technical-fundamentals/python/coding/problems/tests/lists/__pycache__/__init__.cpython-314.pyc
 create mode 100644 technical-fundamentals/python/coding/problems/tests/lists/__pycache__/test_11_remove_dups.cpython-314-pytest-9.0.3.pyc
 create mode 100644 technical-fundamentals/python/coding/problems/tests/lists/__pycache__/test_12_kth_to_last.cpython-314-pytest-9.0.3.pyc
 create mode 100644 technical-fundamentals/python/coding/problems/tests/lists/__pycache__/test_13_delete_middle_node.cpython-314-pytest-9.0.3.pyc
 create mode 100644 technical-fundamentals/python/coding/problems/tests/lists/__pycache__/test_14_partition.cpython-314-pytest-9.0.3.pyc
 create mode 100644 technical-fundamentals/python/coding/problems/tests/lists/__pycache__/test_15_sum_lists.cpython-314-pytest-9.0.3.pyc
 create mode 100644 technical-fundamentals/python/coding/problems/tests/lists/__pycache__/test_16_sum_lists_forward_order.cpython-314-pytest-9.0.3.pyc
 create mode 100644 technical-fundamentals/python/coding/problems/tests/lists/__pycache__/test_17_palindrome.cpython-314-pytest-9.0.3.pyc
 create mode 100644 technical-fundamentals/python/coding/problems/tests/lists/__pycache__/test_18_intersection.cpython-314-pytest-9.0.3.pyc
 create mode 100644 technical-fundamentals/python/coding/problems/tests/lists/__pycache__/test_19_loop_detection.cpython-314-pytest-9.0.3.pyc
 create mode 100644 technical-fundamentals/python/coding/problems/tests/lists/test_11_remove_dups.py
 create mode 100644 technical-fundamentals/python/coding/problems/tests/lists/test_12_kth_to_last.py
 create mode 100644 technical-fundamentals/python/coding/problems/tests/lists/test_13_delete_middle_node.py
 create mode 100644 technical-fundamentals/python/coding/problems/tests/lists/test_14_partition.py
 create mode 100644 technical-fundamentals/python/coding/problems/tests/lists/test_15_sum_lists.py
 create mode 100644 technical-fundamentals/python/coding/problems/tests/lists/test_16_sum_lists_forward_order.py
 create mode 100644 technical-fundamentals/python/coding/problems/tests/lists/test_17_palindrome.py
 create mode 100644 technical-fundamentals/python/coding/problems/tests/lists/test_18_intersection.py
 create mode 100644 technical-fundamentals/python/coding/problems/tests/lists/test_19_loop_detection.py
 create mode 100644 technical-fundamentals/python/coding/problems/tests/recursion/__init__.py
 create mode 100644 technical-fundamentals/python/coding/problems/tests/recursion/__pycache__/__init__.cpython-314.pyc
 create mode 100644 technical-fundamentals/python/coding/problems/tests/recursion/__pycache__/test_41_triple_steps.cpython-314-pytest-9.0.3.pyc
 create mode 100644 technical-fundamentals/python/coding/problems/tests/recursion/__pycache__/test_42_robot_in_a_grid.cpython-314-pytest-9.0.3.pyc
 create mode 100644 technical-fundamentals/python/coding/problems/tests/recursion/__pycache__/test_43_magic_index.cpython-314-pytest-9.0.3.pyc
 create mode 100644 technical-fundamentals/python/coding/problems/tests/recursion/__pycache__/test_44_power_set.cpython-314-pytest-9.0.3.pyc
 create mode 100644 technical-fundamentals/python/coding/problems/tests/recursion/__pycache__/test_45_recursive_multiply.cpython-314-pytest-9.0.3.pyc
 create mode 100644 technical-fundamentals/python/coding/problems/tests/recursion/__pycache__/test_46_towers_of_hanoi.cpython-314-pytest-9.0.3.pyc
 create mode 100644 technical-fundamentals/python/coding/problems/tests/recursion/__pycache__/test_47_permutations_with_dups.cpython-314-pytest-9.0.3.pyc
 create mode 100644 technical-fundamentals/python/coding/problems/tests/recursion/__pycache__/test_48_coin_change.cpython-314-pytest-9.0.3.pyc
 create mode 100644 technical-fundamentals/python/coding/problems/tests/recursion/test_41_triple_steps.py
 create mode 100644 technical-fundamentals/python/coding/problems/tests/recursion/test_42_robot_in_a_grid.py
 create mode 100644 technical-fundamentals/python/coding/problems/tests/recursion/test_43_magic_index.py
 create mode 100644 technical-fundamentals/python/coding/problems/tests/recursion/test_44_power_set.py
 create mode 100644 technical-fundamentals/python/coding/problems/tests/recursion/test_45_recursive_multiply.py
 create mode 100644 technical-fundamentals/python/coding/problems/tests/recursion/test_46_towers_of_hanoi.py
 create mode 100644 technical-fundamentals/python/coding/problems/tests/recursion/test_47_permutations_with_dups.py
 create mode 100644 technical-fundamentals/python/coding/problems/tests/recursion/test_48_coin_change.py
 create mode 100644 technical-fundamentals/python/coding/problems/tests/stacks/__init__.py
 create mode 100644 technical-fundamentals/python/coding/problems/tests/stacks/__pycache__/__init__.cpython-314.pyc
 create mode 100644 technical-fundamentals/python/coding/problems/tests/stacks/__pycache__/test_21_three_stacks.cpython-314-pytest-9.0.3.pyc
 create mode 100644 technical-fundamentals/python/coding/problems/tests/stacks/__pycache__/test_22_stack_min.cpython-314-pytest-9.0.3.pyc
 create mode 100644 technical-fundamentals/python/coding/problems/tests/stacks/__pycache__/test_23_stack_of_plates.cpython-314-pytest-9.0.3.pyc
 create mode 100644 technical-fundamentals/python/coding/problems/tests/stacks/__pycache__/test_24_queue_via_stacks.cpython-314-pytest-9.0.3.pyc
 create mode 100644 technical-fundamentals/python/coding/problems/tests/stacks/__pycache__/test_25_sort_stack.cpython-314-pytest-9.0.3.pyc
 create mode 100644 technical-fundamentals/python/coding/problems/tests/stacks/__pycache__/test_26_animal_shelter.cpython-314-pytest-9.0.3.pyc
 create mode 100644 technical-fundamentals/python/coding/problems/tests/stacks/test_21_three_stacks.py
 create mode 100644 technical-fundamentals/python/coding/problems/tests/stacks/test_22_stack_min.py
 create mode 100644 technical-fundamentals/python/coding/problems/tests/stacks/test_23_stack_of_plates.py
 create mode 100644 technical-fundamentals/python/coding/problems/tests/stacks/test_24_queue_via_stacks.py
 create mode 100644 technical-fundamentals/python/coding/problems/tests/stacks/test_25_sort_stack.py
 create mode 100644 technical-fundamentals/python/coding/problems/tests/stacks/test_26_animal_shelter.py
 create mode 100644 technical-fundamentals/python/coding/problems/tests/strings/__init__.py
 create mode 100644 technical-fundamentals/python/coding/problems/tests/strings/__pycache__/__init__.cpython-314.pyc
 create mode 100644 technical-fundamentals/python/coding/problems/tests/strings/__pycache__/test_01_is_unique.cpython-314-pytest-9.0.3.pyc
 create mode 100644 technical-fundamentals/python/coding/problems/tests/strings/__pycache__/test_02_check_permutations.cpython-314-pytest-9.0.3.pyc
 create mode 100644 technical-fundamentals/python/coding/problems/tests/strings/__pycache__/test_03_urlify.cpython-314-pytest-9.0.3.pyc
 create mode 100644 technical-fundamentals/python/coding/problems/tests/strings/__pycache__/test_04_palindrome_permutation.cpython-314-pytest-9.0.3.pyc
 create mode 100644 technical-fundamentals/python/coding/problems/tests/strings/__pycache__/test_05_one_away.cpython-314-pytest-9.0.3.pyc
 create mode 100644 technical-fundamentals/python/coding/problems/tests/strings/__pycache__/test_06_string_compression.cpython-314-pytest-9.0.3.pyc
 create mode 100644 technical-fundamentals/python/coding/problems/tests/strings/__pycache__/test_07_rotate_matrix.cpython-314-pytest-9.0.3.pyc
 create mode 100644 technical-fundamentals/python/coding/problems/tests/strings/__pycache__/test_08_zero_matrix.cpython-314-pytest-9.0.3.pyc
 create mode 100644 technical-fundamentals/python/coding/problems/tests/strings/__pycache__/test_09_string_rotation.cpython-314-pytest-9.0.3.pyc
 create mode 100644 technical-fundamentals/python/coding/problems/tests/strings/test_01_is_unique.py
 create mode 100644 technical-fundamentals/python/coding/problems/tests/strings/test_02_check_permutations.py
 create mode 100644 technical-fundamentals/python/coding/problems/tests/strings/test_03_urlify.py
 create mode 100644 technical-fundamentals/python/coding/problems/tests/strings/test_04_palindrome_permutation.py
 create mode 100644 technical-fundamentals/python/coding/problems/tests/strings/test_05_one_away.py
 create mode 100644 technical-fundamentals/python/coding/problems/tests/strings/test_06_string_compression.py
 create mode 100644 technical-fundamentals/python/coding/problems/tests/strings/test_07_rotate_matrix.py
 create mode 100644 technical-fundamentals/python/coding/problems/tests/strings/test_08_zero_matrix.py
 create mode 100644 technical-fundamentals/python/coding/problems/tests/strings/test_09_string_rotation.py
 create mode 100644 technical-fundamentals/python/coding/problems/tests/trees/__init__.py
 create mode 100644 technical-fundamentals/python/coding/problems/tests/trees/__pycache__/__init__.cpython-314.pyc
 create mode 100644 technical-fundamentals/python/coding/problems/tests/trees/__pycache__/test_30_trees.cpython-314-pytest-9.0.3.pyc
 create mode 100644 technical-fundamentals/python/coding/problems/tests/trees/__pycache__/test_31_has_route_between_nodes.cpython-314-pytest-9.0.3.pyc
 create mode 100644 technical-fundamentals/python/coding/problems/tests/trees/__pycache__/test_32_minimal_tree.cpython-314-pytest-9.0.3.pyc
 create mode 100644 technical-fundamentals/python/coding/problems/tests/trees/__pycache__/test_33_list_of_depths.cpython-314-pytest-9.0.3.pyc
 create mode 100644 technical-fundamentals/python/coding/problems/tests/trees/__pycache__/test_34_check_balanced.cpython-314-pytest-9.0.3.pyc
 create mode 100644 technical-fundamentals/python/coding/problems/tests/trees/__pycache__/test_35_validate_bst.cpython-314-pytest-9.0.3.pyc
 create mode 100644 technical-fundamentals/python/coding/problems/tests/trees/__pycache__/test_36_successor.cpython-314-pytest-9.0.3.pyc
 create mode 100644 technical-fundamentals/python/coding/problems/tests/trees/__pycache__/test_37_build_order.cpython-314-pytest-9.0.3.pyc
 create mode 100644 technical-fundamentals/python/coding/problems/tests/trees/__pycache__/test_38_first_common_ancestor.cpython-314-pytest-9.0.3.pyc
 create mode 100644 technical-fundamentals/python/coding/problems/tests/trees/__pycache__/test_39_bst_sequences.cpython-314-pytest-9.0.3.pyc
 create mode 100644 technical-fundamentals/python/coding/problems/tests/trees/test_30_trees.py
 create mode 100644 technical-fundamentals/python/coding/problems/tests/trees/test_31_has_route_between_nodes.py
 create mode 100644 technical-fundamentals/python/coding/problems/tests/trees/test_32_minimal_tree.py
 create mode 100644 technical-fundamentals/python/coding/problems/tests/trees/test_33_list_of_depths.py
 create mode 100644 technical-fundamentals/python/coding/problems/tests/trees/test_34_check_balanced.py
 create mode 100644 technical-fundamentals/python/coding/problems/tests/trees/test_35_validate_bst.py
 create mode 100644 technical-fundamentals/python/coding/problems/tests/trees/test_36_successor.py
 create mode 100644 technical-fundamentals/python/coding/problems/tests/trees/test_37_build_order.py
 create mode 100644 technical-fundamentals/python/coding/problems/tests/trees/test_38_first_common_ancestor.py
 create mode 100644 technical-fundamentals/python/coding/problems/tests/trees/test_39_bst_sequences.py
 create mode 100644 technical-fundamentals/python/coding/problems/tools/add_js_docstrings.py
 create mode 100644 technical-fundamentals/python/coding/problems/tools/fix_docstrings.py
 create mode 100644 technical-fundamentals/python/coding/problems/utils/__init__.py
 create mode 100644 technical-fundamentals/python/coding/problems/utils/__pycache__/__init__.cpython-314.pyc
 create mode 100644 technical-fundamentals/python/coding/problems/utils/__pycache__/strings.cpython-314.pyc
 create mode 100644 technical-fundamentals/python/coding/problems/utils/strings.py
 create mode 100644 technical-fundamentals/python/conftest.py
 create mode 100644 technical-fundamentals/python/pytest.ini
 create mode 100644 technical-fundamentals/python/requirements.txt

diff --git a/technical-fundamentals/python/README.md b/technical-fundamentals/python/README.md
new file mode 100644
index 00000000..9be4d8c0
--- /dev/null
+++ b/technical-fundamentals/python/README.md
@@ -0,0 +1,42 @@
+# Coding Challenges — Python
+
+Python version of the Cracking the Coding Interview exercises.
+
+## Getting Started
+
+1. Install dependencies:
+   ```bash
+   python3 -m venv venv
+   source venv/bin/activate
+   pip install -r requirements.txt
+   ```
+
+2. Run all tests:
+   ```bash
+   pytest
+   ```
+
+## Running Tests by Category
+
+```bash
+pytest coding/problems/tests/strings/
+pytest coding/problems/tests/lists/
+pytest coding/problems/tests/stacks/
+pytest coding/problems/tests/trees/
+pytest coding/problems/tests/recursion/
+```
+
+## Running a Single Problem
+
+```bash
+pytest -k is_unique
+pytest -k minimal_tree
+pytest -k triple_step
+```
+
+## How It Works
+
+Each problem lives in `coding/problems/NN_problem_name.py` as a stub function or class.  
+Fill in the implementation and run the tests to verify your solution.
+
+Tests import directly from the solution files — same pattern as the JavaScript side.
diff --git a/technical-fundamentals/python/__pycache__/conftest.cpython-314-pytest-9.0.3.pyc b/technical-fundamentals/python/__pycache__/conftest.cpython-314-pytest-9.0.3.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..db0437366507ba4201f65b5427ae77997c8c4f70
GIT binary patch
literal 3158
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
V@zzlHPlI94<jbR7o(|im{{jY@P@(_;

literal 0
HcmV?d00001

diff --git a/technical-fundamentals/python/__pycache__/conftest.cpython-314.pyc b/technical-fundamentals/python/__pycache__/conftest.cpython-314.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..9a37c6a5bfee146588394666d912f7bb532aedb4
GIT binary patch
literal 4137
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
IUfr+%0_#c#MF0Q*

literal 0
HcmV?d00001

diff --git a/technical-fundamentals/python/coding/__init__.py b/technical-fundamentals/python/coding/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/technical-fundamentals/python/coding/__pycache__/__init__.cpython-314.pyc b/technical-fundamentals/python/coding/__pycache__/__init__.cpython-314.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f9e85c3fb5dfaefe1d5a078c19a636074d762200
GIT binary patch
literal 191
zcmdPq<K<!if?}ngnIQTxh=2h`DC095kkP;p#GuTe$>_I|p@<2{{|u766{8<ooLW?@
zpPN{cSyrqcP?VpQnp{$>Z)jkUt)H1!l3G-jnOd$}l$w}Qsb7+soROEAoS37VR+^WR
zn46kcl9*GhUr<?+k)NlZoS%}Jm#!ZlpP83g5+AQuP<e~PCO1E&G$+-rh!toV$T`Iz
O#wTV*M#ds$APWG^k1_xN

literal 0
HcmV?d00001

diff --git a/technical-fundamentals/python/coding/problems/01_is_unique.py b/technical-fundamentals/python/coding/problems/01_is_unique.py
new file mode 100644
index 00000000..9be90514
--- /dev/null
+++ b/technical-fundamentals/python/coding/problems/01_is_unique.py
@@ -0,0 +1,12 @@
+# 1. Is Unique:
+# Implement an algorithm to determine if a string has all unique characters.
+# What if you cannot use additional data structures?
+
+
+def is_unique(s: str) -> bool:
+    hashmap = {}
+    for c in s:
+        if c in hashmap:
+            return False
+        hashmap[c] = True
+    return True
diff --git a/technical-fundamentals/python/coding/problems/02_check_permutations.py b/technical-fundamentals/python/coding/problems/02_check_permutations.py
new file mode 100644
index 00000000..c5bff379
--- /dev/null
+++ b/technical-fundamentals/python/coding/problems/02_check_permutations.py
@@ -0,0 +1,18 @@
+# 2. Check Permutation:
+# Given two strings, write a method to decide if one is a permutation of the other.
+
+
+def check_permutations(s1: str, s2: str) -> bool:
+    hashmap = {}
+    for c in s1:
+        if c not in hashmap:
+            hashmap[c] = 0
+        hashmap[c] += 1
+
+    for c in s2:
+        if c in hashmap:
+            hashmap[c] -= 1
+        else:
+            return False
+
+    return all([x == 0 for x in hashmap.values()])
\ No newline at end of file
diff --git a/technical-fundamentals/python/coding/problems/03_urlify.py b/technical-fundamentals/python/coding/problems/03_urlify.py
new file mode 100644
index 00000000..6c84a1e7
--- /dev/null
+++ b/technical-fundamentals/python/coding/problems/03_urlify.py
@@ -0,0 +1,14 @@
+# 3. URLify:
+# Write a method to replace all spaces in a string with '%20'.
+# You may assume that the string has sufficient space at the end to hold the additional
+# characters, and that you are given the "true" length of the string.
+
+
+def urlify(s: str) -> str:
+    answer = ""
+    for c in s:
+        if c == ' ':
+            answer += '%20'
+        else:
+            answer += c
+    return answer
\ No newline at end of file
diff --git a/technical-fundamentals/python/coding/problems/04_palindrome_permutation.py b/technical-fundamentals/python/coding/problems/04_palindrome_permutation.py
new file mode 100644
index 00000000..e36b7033
--- /dev/null
+++ b/technical-fundamentals/python/coding/problems/04_palindrome_permutation.py
@@ -0,0 +1,26 @@
+# 4. Palindrome Permutation:
+# Given a string, write a function to check if it is a permutation of a palindrome.
+# A palindrome is a word or phrase that is the same forwards and backwards.
+# A permutation is a rearrangement of letters. The palindrome does not need to be
+# limited to just dictionary words.
+#
+# EXAMPLE
+# Input: Tact Coa
+# Output: True (permutations: "taco cat", "atco cta", etc.)
+
+
+def palindrome_permutation(s: str) -> bool:
+    hashmap = {}
+    counter = 0
+    for c in s:
+        c = c.lower()
+        if c == ' ':
+            continue
+        if c not in hashmap:
+            hashmap[c] = True
+            counter += 1
+        else:
+            del hashmap[c]
+            counter -= 1
+    return counter <= 1
+
diff --git a/technical-fundamentals/python/coding/problems/05_one_away.py b/technical-fundamentals/python/coding/problems/05_one_away.py
new file mode 100644
index 00000000..648e15b4
--- /dev/null
+++ b/technical-fundamentals/python/coding/problems/05_one_away.py
@@ -0,0 +1,48 @@
+# 5. One Away:
+# There are three types of edits that can be performed on strings:
+# insert a character, remove a character, or replace a character.
+# Given two strings, write a function to check if they are one edit (or zero edits) away.
+
+
+def is_one_away(s1: str, s2: str) -> bool:
+    if s1 == s2:
+        return True
+
+    len_s1 = len(s1)
+    len_s2 = len(s2)
+
+    if len_s1 == len_s2:
+        diffs = 0
+        for i in range(len_s1):
+            if s1[i] != s2[i]:
+                if diffs > 0:
+                    return False
+                diffs += 1
+        return True
+
+    if abs(len_s1 - len_s2) > 1:
+        return  False
+
+    if len_s1 > len_s2:
+        small = s2
+        big = s1
+    else:
+        small = s1
+        big = s2
+
+    diffs = 0
+    for i in range(len(small)):
+        if small[i] != big[i+diffs]:
+            if diffs > 0:
+                return False
+            diffs += 1
+
+    return True
+
+
+
+    
+
+
+
+    return False
diff --git a/technical-fundamentals/python/coding/problems/06_string_compression.py b/technical-fundamentals/python/coding/problems/06_string_compression.py
new file mode 100644
index 00000000..baee10f0
--- /dev/null
+++ b/technical-fundamentals/python/coding/problems/06_string_compression.py
@@ -0,0 +1,27 @@
+# 6. String Compression:
+# Implement a method to perform basic string compression using the counts of repeated
+# characters. For example, the string aabcccccaaa would become a2b1c5a3.
+# If the "compressed" string would not become smaller than the original string,
+# your method should return the original string.
+# You can assume the string has only uppercase and lowercase letters (a-z).
+
+
+def string_compression(s: str) -> str:
+    if not s:
+        return s
+
+    len_s = len(s)
+    c = s[0]
+    counter = 1
+    answer = ""
+    for i in range(1, len(s)):
+        if s[i] == c:
+            counter += 1
+        else:
+            answer += c + str(counter)
+            c = s[i]
+            counter = 1
+    answer += c + str(counter)
+    if len(answer) >= len_s:
+        return s
+    return answer
diff --git a/technical-fundamentals/python/coding/problems/07_rotate_matrix.py b/technical-fundamentals/python/coding/problems/07_rotate_matrix.py
new file mode 100644
index 00000000..ea56a8fd
--- /dev/null
+++ b/technical-fundamentals/python/coding/problems/07_rotate_matrix.py
@@ -0,0 +1,27 @@
+# 7. Rotate Matrix:
+# Given an image represented by an NxN matrix, where each pixel in the image is 4
+# bytes, write a method to rotate the image by 90 degrees. Can you do this in place?
+
+from typing import List
+
+Matrix = List[List[int]]
+
+# 1, "2", 3, 4
+# 5, 6, 7, "8"
+# "9", 10, 11, 12
+# 13, 14, "15", 16
+# 
+# 0, 1 - 1, 3 - 3, 2 - 2, 0
+
+def rotate_matrix(matrix: Matrix) -> None:
+    n = len(matrix)
+    for i in range(n//2):
+        for j in range(i, n - i - 1):
+            first = matrix[i][j]
+            second = matrix[j][n-i-1]
+            third = matrix[n-i-1][n-j-1]
+            fourth = matrix[n-j-1][i]
+            matrix[i][j] = fourth
+            matrix[j][n-i-1] = first
+            matrix[n-i-1][n-j-1] = second
+            matrix[n-j-1][i] = third
\ No newline at end of file
diff --git a/technical-fundamentals/python/coding/problems/08_zero_matrix.py b/technical-fundamentals/python/coding/problems/08_zero_matrix.py
new file mode 100644
index 00000000..f61278da
--- /dev/null
+++ b/technical-fundamentals/python/coding/problems/08_zero_matrix.py
@@ -0,0 +1,37 @@
+# 8. Zero Matrix:
+# Write an algorithm such that if an element in an MxN matrix is 0,
+# its entire row and column are set to 0.
+
+from typing import List
+
+Matrix = List[List[int]]
+
+
+def zero_matrix(matrix: Matrix) -> None:
+    first_row = False
+    first_column = False
+    print(matrix)
+    for i in range(len(matrix)):
+        for j in range(len(matrix[i])):
+            if matrix[i][j] == 0:
+                if i == 0:
+                    first_row = True
+                if j == 0:
+                    first_column = True
+                matrix[i][0] = 0
+                matrix[0][j] = 0
+    
+    for i in range(1, len(matrix)):
+        for j in range(1, len(matrix[i])):
+            if matrix[i][0] == 0:
+                matrix[i][j] = 0
+            if matrix[0][j] == 0:
+                matrix[i][j] = 0
+
+    if first_row:
+        for j in range(len(matrix[0])):
+            matrix[0][j] = 0
+    if first_column:
+        for i in range(len(matrix)):
+            matrix[i][0] = 0
+
diff --git a/technical-fundamentals/python/coding/problems/09_string_rotation.py b/technical-fundamentals/python/coding/problems/09_string_rotation.py
new file mode 100644
index 00000000..fa7a021e
--- /dev/null
+++ b/technical-fundamentals/python/coding/problems/09_string_rotation.py
@@ -0,0 +1,11 @@
+# 9. String Rotation:
+# Assume you have a method is_substring which checks if one word is a substring of another.
+# Given two strings, s1 and s2, write code to check if s2 is a rotation of s1 using
+# only one call to is_substring.
+# e.g., "waterbottle" is a rotation of "erbottlewat"
+
+from coding.problems.utils.strings import is_substring
+
+
+def string_rotation(s1: str, s2: str) -> bool:
+    return s1 in s2 + s2
diff --git a/technical-fundamentals/python/coding/problems/10_linked_list.py b/technical-fundamentals/python/coding/problems/10_linked_list.py
new file mode 100644
index 00000000..f9806f78
--- /dev/null
+++ b/technical-fundamentals/python/coding/problems/10_linked_list.py
@@ -0,0 +1,39 @@
+# 10. *Implement a Linked List*
+#
+# Create the data structure with the corresponding initial functions.
+
+from __future__ import annotations
+from typing import TypeVar, Generic, Optional, Callable
+
+T = TypeVar("T")
+
+
+class Node(Generic[T]):
+    def __init__(self, value: T, next: Optional["Node[T]"] = None):
+        self.value = value
+        self.next = next
+
+
+class LinkedList(Generic[T]):
+    def __init__(self, head: Optional[Node[T]] = None):
+        self.head: Optional[Node[T]] = head
+        self.tail: Optional[Node[T]] = head
+        self.length: int = 0
+
+    def push(self, value: T) -> None:
+        pass
+
+    def filter(self, predicate: Callable[[T], bool]) -> "LinkedList[T]":
+        pass
+
+    def visit(self, callback: Callable[[T], None]) -> None:
+        pass
+
+    def remove(self, value: T) -> None:
+        pass
+
+    def merge(self, other: "LinkedList[T]") -> None:
+        pass
+
+    def print(self) -> None:
+        pass
diff --git a/technical-fundamentals/python/coding/problems/11_remove_dups.py b/technical-fundamentals/python/coding/problems/11_remove_dups.py
new file mode 100644
index 00000000..a7b12d7f
--- /dev/null
+++ b/technical-fundamentals/python/coding/problems/11_remove_dups.py
@@ -0,0 +1,20 @@
+# 11. Remove Dups:
+# Write code to remove duplicates from an unsorted linked list.
+# FOLLOW UP: How would you solve this problem if a temporary buffer is not allowed?
+#
+# 1 -> 2 -> 2 -> 2 -> 4
+
+from __future__ import annotations
+from typing import TypeVar, Generic, Optional
+
+T = TypeVar("T")
+
+
+class Node(Generic[T]):
+    def __init__(self, value: T, next: Optional["Node[T]"] = None):
+        self.value = value
+        self.next = next
+
+
+def remove_dups(head: Optional[Node[T]] = None) -> Optional[Node[T]]:
+    pass
diff --git a/technical-fundamentals/python/coding/problems/12_kth_to_last.py b/technical-fundamentals/python/coding/problems/12_kth_to_last.py
new file mode 100644
index 00000000..cfd10f3f
--- /dev/null
+++ b/technical-fundamentals/python/coding/problems/12_kth_to_last.py
@@ -0,0 +1,17 @@
+# 12. Return Kth to Last:
+# Implement an algorithm to find the kth to last element of a singly linked list.
+
+from __future__ import annotations
+from typing import TypeVar, Generic, Optional
+
+T = TypeVar("T")
+
+
+class Node(Generic[T]):
+    def __init__(self, value: T, next: Optional["Node[T]"] = None):
+        self.value = value
+        self.next = next
+
+
+def kth_to_last(head: Node[T], k: int) -> Optional[Node[T]]:
+    pass
diff --git a/technical-fundamentals/python/coding/problems/13_delete_middle_node.py b/technical-fundamentals/python/coding/problems/13_delete_middle_node.py
new file mode 100644
index 00000000..0447e1ca
--- /dev/null
+++ b/technical-fundamentals/python/coding/problems/13_delete_middle_node.py
@@ -0,0 +1,23 @@
+# 13. Delete Middle Node:
+# Implement an algorithm to delete a node in the middle
+# (i.e., any node but the first and last node, not necessarily the exact middle)
+# of a singly linked list, given only access to that node.
+#
+# EXAMPLE
+# Input: the node c from the linked list a->b->c->d->e->f
+# Result: nothing is returned, but the new linked list looks like a->b->d->e->f
+
+from __future__ import annotations
+from typing import TypeVar, Generic, Optional
+
+T = TypeVar("T")
+
+
+class Node(Generic[T]):
+    def __init__(self, value: T, next: Optional["Node[T]"] = None):
+        self.value = value
+        self.next = next
+
+
+def delete_middle_node(head: Node[T], position: int) -> Optional[Node[T]]:
+    pass
diff --git a/technical-fundamentals/python/coding/problems/14_partition.py b/technical-fundamentals/python/coding/problems/14_partition.py
new file mode 100644
index 00000000..2a6aa993
--- /dev/null
+++ b/technical-fundamentals/python/coding/problems/14_partition.py
@@ -0,0 +1,24 @@
+# 14. Partition:
+# Write code to partition a linked list around a value x, such that all nodes less
+# than x come before all nodes greater than or equal to x. If x is contained within
+# the list, the values of x only need to be after the elements less than x.
+# The partition element x can appear anywhere in the "right partition".
+#
+# EXAMPLE
+# Input: 3 -> 5 -> 8 -> 5 -> 10 -> 2 -> 1 [partition=5]
+# Output: 3 -> 1 -> 2 -> 10 -> 5 -> 5 -> 8
+
+from __future__ import annotations
+from typing import TypeVar, Generic, Optional
+
+T = TypeVar("T")
+
+
+class Node(Generic[T]):
+    def __init__(self, value: T, next: Optional["Node[T]"] = None):
+        self.value = value
+        self.next = next
+
+
+def partition(head: Optional[Node[T]], x: T) -> Optional[Node[T]]:
+    pass
diff --git a/technical-fundamentals/python/coding/problems/15_sum_lists.py b/technical-fundamentals/python/coding/problems/15_sum_lists.py
new file mode 100644
index 00000000..bd170e5e
--- /dev/null
+++ b/technical-fundamentals/python/coding/problems/15_sum_lists.py
@@ -0,0 +1,25 @@
+# 15. Sum Lists:
+# You have two numbers represented by a linked list, where each node contains a
+# single digit. The digits are stored in reverse order, such that the 1's digit is
+# at the head of the list. Write a function that adds the two numbers and returns
+# the sum as a linked list.
+#
+# EXAMPLE
+# Input: (7 -> 1 -> 6) + (5 -> 9 -> 2). That is, 617 + 295.
+# Output: 2 -> 1 -> 9. That is, 912.
+
+from __future__ import annotations
+from typing import Optional
+
+
+class Node:
+    def __init__(self, value: int, next: Optional["Node"] = None):
+        self.value = value
+        self.next = next
+
+
+def sum_lists(
+    list1: Optional[Node],
+    list2: Optional[Node],
+) -> Optional[Node]:
+    pass
diff --git a/technical-fundamentals/python/coding/problems/16_sum_lists_forward_order.py b/technical-fundamentals/python/coding/problems/16_sum_lists_forward_order.py
new file mode 100644
index 00000000..0f988bf7
--- /dev/null
+++ b/technical-fundamentals/python/coding/problems/16_sum_lists_forward_order.py
@@ -0,0 +1,22 @@
+# 16. Sum Lists (Forward Order):
+# Suppose the digits are stored in forward order. Repeat the above problem.
+#
+# EXAMPLE
+# Input: (6 -> 1 -> 7) + (2 -> 9 -> 5). That is, 617 + 295.
+# Output: 9 -> 1 -> 2. That is, 912.
+
+from __future__ import annotations
+from typing import Optional
+
+
+class Node:
+    def __init__(self, value: int, next: Optional["Node"] = None):
+        self.value = value
+        self.next = next
+
+
+def sum_lists_forward_order(
+    list1: Optional[Node],
+    list2: Optional[Node],
+) -> Optional[Node]:
+    pass
diff --git a/technical-fundamentals/python/coding/problems/17_palindrome.py b/technical-fundamentals/python/coding/problems/17_palindrome.py
new file mode 100644
index 00000000..6164ce1c
--- /dev/null
+++ b/technical-fundamentals/python/coding/problems/17_palindrome.py
@@ -0,0 +1,17 @@
+# 17. Palindrome:
+# Implement a function to check if a linked list is a palindrome.
+
+from __future__ import annotations
+from typing import TypeVar, Generic, Optional
+
+T = TypeVar("T")
+
+
+class Node(Generic[T]):
+    def __init__(self, value: T, next: Optional["Node[T]"] = None):
+        self.value = value
+        self.next = next
+
+
+def is_palindrome(head: Optional[Node[T]]) -> bool:
+    pass
diff --git a/technical-fundamentals/python/coding/problems/18_intersection.py b/technical-fundamentals/python/coding/problems/18_intersection.py
new file mode 100644
index 00000000..78422b6d
--- /dev/null
+++ b/technical-fundamentals/python/coding/problems/18_intersection.py
@@ -0,0 +1,22 @@
+# 18. Intersection:
+# Given two (singly) linked lists, determine if the two lists intersect.
+# Return the first intersecting node. Note that the intersection is defined
+# based on reference, not value.
+
+from __future__ import annotations
+from typing import TypeVar, Generic, Optional
+
+T = TypeVar("T")
+
+
+class Node(Generic[T]):
+    def __init__(self, value: T, next: Optional["Node[T]"] = None):
+        self.value = value
+        self.next = next
+
+
+def intersection(
+    list1: Optional[Node[T]],
+    list2: Optional[Node[T]],
+) -> Optional[Node[T]]:
+    pass
diff --git a/technical-fundamentals/python/coding/problems/19_loop_detection.py b/technical-fundamentals/python/coding/problems/19_loop_detection.py
new file mode 100644
index 00000000..b3aaf99c
--- /dev/null
+++ b/technical-fundamentals/python/coding/problems/19_loop_detection.py
@@ -0,0 +1,26 @@
+# 19. Loop Detection:
+# Given a circular linked list, implement an algorithm that returns the node
+# at the beginning of the loop.
+#
+# DEFINITION
+# Circular linked list: A (corrupt) linked list in which a node's next pointer
+# points to an earlier node, so as to make a loop in the linked list.
+#
+# EXAMPLE
+# Input: A->B->C->D->E->C [the same C as earlier]
+# Output: C
+
+from __future__ import annotations
+from typing import TypeVar, Generic, Optional
+
+T = TypeVar("T")
+
+
+class Node(Generic[T]):
+    def __init__(self, value: T, next: Optional["Node[T]"] = None):
+        self.value = value
+        self.next = next
+
+
+def detect_loop(head: Optional[Node[T]]) -> Optional[Node[T]]:
+    pass
diff --git a/technical-fundamentals/python/coding/problems/21_three_stacks.py b/technical-fundamentals/python/coding/problems/21_three_stacks.py
new file mode 100644
index 00000000..2692efa2
--- /dev/null
+++ b/technical-fundamentals/python/coding/problems/21_three_stacks.py
@@ -0,0 +1,20 @@
+# 21. Three in One:
+# Describe how you could use a single array to implement three stacks.
+
+from typing import TypeVar, Generic, Optional, List
+
+T = TypeVar("T")
+
+
+class ThreeStacks(Generic[T]):
+    def __init__(self, array_length: int):
+        pass
+
+    def push(self, stack_num: int, value: T) -> None:
+        pass
+
+    def pop(self, stack_num: int) -> Optional[T]:
+        pass
+
+    def peek(self, stack_num: int) -> Optional[T]:
+        pass
diff --git a/technical-fundamentals/python/coding/problems/22_stack_min.py b/technical-fundamentals/python/coding/problems/22_stack_min.py
new file mode 100644
index 00000000..9d2a9d04
--- /dev/null
+++ b/technical-fundamentals/python/coding/problems/22_stack_min.py
@@ -0,0 +1,22 @@
+# 22. Stack Min:
+# How would you design a stack which, in addition to push and pop, has a function
+# min which returns the minimum element?
+# Push, pop, and min should all operate in O(1) time.
+
+from typing import TypeVar, Generic, Optional
+
+T = TypeVar("T")
+
+
+class StackMin(Generic[T]):
+    def __init__(self):
+        pass
+
+    def push(self, value: T) -> None:
+        pass
+
+    def pop(self) -> Optional[T]:
+        pass
+
+    def min(self) -> Optional[T]:
+        pass
diff --git a/technical-fundamentals/python/coding/problems/23_stack_of_plates.py b/technical-fundamentals/python/coding/problems/23_stack_of_plates.py
new file mode 100644
index 00000000..da20200a
--- /dev/null
+++ b/technical-fundamentals/python/coding/problems/23_stack_of_plates.py
@@ -0,0 +1,24 @@
+# 23. Stack of Plates:
+# Imagine a (literal) stack of plates. If the stack gets too high, it might topple.
+# Therefore, in real life, we would likely start a new stack when the previous stack
+# exceeds some threshold. Implement a data structure SetOfStacks that mimics this.
+# SetOfStacks should be composed of several stacks and should create a new stack once
+# the previous one exceeds capacity. SetOfStacks.push() and SetOfStacks.pop() should
+# behave identically to a single stack.
+#
+# FOLLOW UP: Implement a function pop_at(index) which performs a pop on a specific sub-stack.
+
+from typing import TypeVar, Generic, Optional
+
+T = TypeVar("T")
+
+
+class StackOfPlates(Generic[T]):
+    def __init__(self, capacity: int):
+        pass
+
+    def push(self, value: T) -> None:
+        pass
+
+    def pop(self) -> Optional[T]:
+        pass
diff --git a/technical-fundamentals/python/coding/problems/24_queue_via_stacks.py b/technical-fundamentals/python/coding/problems/24_queue_via_stacks.py
new file mode 100644
index 00000000..46cc0d62
--- /dev/null
+++ b/technical-fundamentals/python/coding/problems/24_queue_via_stacks.py
@@ -0,0 +1,23 @@
+# 24. Queue via Stacks:
+# Implement a MyQueue class which implements a queue using two stacks.
+
+from typing import TypeVar, Generic, Optional
+
+T = TypeVar("T")
+
+
+class MyQueue(Generic[T]):
+    def __init__(self):
+        pass
+
+    def enqueue(self, value: T) -> None:
+        pass
+
+    def dequeue(self) -> Optional[T]:
+        pass
+
+    def peek(self) -> Optional[T]:
+        pass
+
+    def is_empty(self) -> bool:
+        pass
diff --git a/technical-fundamentals/python/coding/problems/25_sort_stack.py b/technical-fundamentals/python/coding/problems/25_sort_stack.py
new file mode 100644
index 00000000..3f784e66
--- /dev/null
+++ b/technical-fundamentals/python/coding/problems/25_sort_stack.py
@@ -0,0 +1,26 @@
+# 25. Sort Stack:
+# Write a program to sort a stack such that the smallest items are on the top.
+# You can use an additional temporary stack, but you may not copy the elements
+# into any other data structure (such as an array).
+# The stack supports the following operations: push, pop, peek, and is_empty.
+
+from typing import TypeVar, Generic, Optional
+
+T = TypeVar("T")
+
+
+class SortStack(Generic[T]):
+    def __init__(self):
+        pass
+
+    def push(self, value: T) -> None:
+        pass
+
+    def pop(self) -> Optional[T]:
+        pass
+
+    def peek(self) -> Optional[T]:
+        pass
+
+    def is_empty(self) -> bool:
+        pass
diff --git a/technical-fundamentals/python/coding/problems/26_animal_shelter.py b/technical-fundamentals/python/coding/problems/26_animal_shelter.py
new file mode 100644
index 00000000..a29ba359
--- /dev/null
+++ b/technical-fundamentals/python/coding/problems/26_animal_shelter.py
@@ -0,0 +1,34 @@
+# 26. Animal Shelter:
+# An animal shelter, which holds only dogs and cats, operates on a strictly
+# "first in, first out" basis. People must adopt either the "oldest" (based on
+# arrival time) of all animals at the shelter, or they can select whether they
+# would prefer a dog or a cat (and will receive the oldest animal of that type).
+# They cannot select which specific animal they would like.
+# Create the data structures to maintain this system and implement operations
+# such as enqueue, dequeue_any, dequeue_dog, and dequeue_cat.
+
+from typing import Literal, Optional
+
+AnimalType = Literal["dog", "cat"]
+
+
+class Animal:
+    def __init__(self, animal_type: AnimalType):
+        self.type = animal_type
+
+
+class AnimalShelter:
+    def __init__(self):
+        pass
+
+    def enqueue(self, animal_type: AnimalType) -> None:
+        pass
+
+    def dequeue_any(self) -> Optional[Animal]:
+        pass
+
+    def dequeue_dog(self) -> Optional[Animal]:
+        pass
+
+    def dequeue_cat(self) -> Optional[Animal]:
+        pass
diff --git a/technical-fundamentals/python/coding/problems/30_trees.py b/technical-fundamentals/python/coding/problems/30_trees.py
new file mode 100644
index 00000000..52155864
--- /dev/null
+++ b/technical-fundamentals/python/coding/problems/30_trees.py
@@ -0,0 +1,36 @@
+# 30. Write the basic tree algorithms of Depth-First Search and Breadth-First Search.
+
+from __future__ import annotations
+from typing import TypeVar, Generic, Optional, Callable
+
+T = TypeVar("T")
+
+
+class TreeNode(Generic[T]):
+    def __init__(
+        self,
+        value: T,
+        left: Optional["TreeNode[T]"] = None,
+        right: Optional["TreeNode[T]"] = None,
+        parent: Optional["TreeNode[T]"] = None,
+    ):
+        self.value = value
+        self.left = left
+        self.right = right
+        self.parent = parent
+
+
+class Tree(Generic[T]):
+    def bfs(
+        self,
+        node: Optional[TreeNode[T]],
+        visit: Callable[[TreeNode[T]], None],
+    ) -> None:
+        pass
+
+    def dfs(
+        self,
+        node: Optional[TreeNode[T]],
+        visit: Callable[[TreeNode[T]], None],
+    ) -> None:
+        pass
diff --git a/technical-fundamentals/python/coding/problems/31_has_route_between_nodes.py b/technical-fundamentals/python/coding/problems/31_has_route_between_nodes.py
new file mode 100644
index 00000000..bb810886
--- /dev/null
+++ b/technical-fundamentals/python/coding/problems/31_has_route_between_nodes.py
@@ -0,0 +1,16 @@
+# 31. Route Between Nodes:
+# Given a directed graph, design an algorithm to find out whether there is a route
+# between two nodes.
+
+from __future__ import annotations
+from typing import List
+
+
+class GraphNode:
+    def __init__(self, value: int, neighbors: List["GraphNode"] = None):
+        self.value = value
+        self.neighbors: List["GraphNode"] = neighbors if neighbors is not None else []
+
+
+def has_route_between_nodes(start: GraphNode, end: GraphNode) -> bool:
+    pass
diff --git a/technical-fundamentals/python/coding/problems/32_minimal_tree.py b/technical-fundamentals/python/coding/problems/32_minimal_tree.py
new file mode 100644
index 00000000..d0f16553
--- /dev/null
+++ b/technical-fundamentals/python/coding/problems/32_minimal_tree.py
@@ -0,0 +1,33 @@
+# 32. Minimal Tree:
+# Given a sorted (increasing order) array with unique integer elements, write an
+# algorithm to create a binary search tree with minimal height.
+#
+# A binary search tree is a search where for each node, lesser elements are on
+# the left node, and greater elements on the right node.
+#
+# Input: [1,2,3,4,5,6,7,8]
+# Output:
+#      5
+#   2  |  7
+# 1   3|6   8
+
+from __future__ import annotations
+from typing import TypeVar, Generic, Optional, List
+
+T = TypeVar("T")
+
+
+class TreeNode(Generic[T]):
+    def __init__(
+        self,
+        value: T,
+        left: Optional["TreeNode[T]"] = None,
+        right: Optional["TreeNode[T]"] = None,
+    ):
+        self.value = value
+        self.left = left
+        self.right = right
+
+
+def minimal_tree(sorted_array: List[T]) -> Optional[TreeNode[T]]:
+    pass
diff --git a/technical-fundamentals/python/coding/problems/33_list_of_depths.py b/technical-fundamentals/python/coding/problems/33_list_of_depths.py
new file mode 100644
index 00000000..196849d6
--- /dev/null
+++ b/technical-fundamentals/python/coding/problems/33_list_of_depths.py
@@ -0,0 +1,30 @@
+# 33. List of Depths:
+# Given a binary tree, design an algorithm which creates a linked list of all the
+# nodes at each depth (e.g., if you have a tree with depth D, you'll have D linked lists).
+
+from __future__ import annotations
+from typing import TypeVar, Generic, Optional, List
+
+T = TypeVar("T")
+
+
+class TreeNode(Generic[T]):
+    def __init__(
+        self,
+        value: T,
+        left: Optional["TreeNode[T]"] = None,
+        right: Optional["TreeNode[T]"] = None,
+    ):
+        self.value = value
+        self.left = left
+        self.right = right
+
+
+class ListNode(Generic[T]):
+    def __init__(self, value: T, next: Optional["ListNode[T]"] = None):
+        self.value = value
+        self.next = next
+
+
+def list_of_depths(root: Optional[TreeNode[T]]) -> List[ListNode[T]]:
+    pass
diff --git a/technical-fundamentals/python/coding/problems/34_check_balanced.py b/technical-fundamentals/python/coding/problems/34_check_balanced.py
new file mode 100644
index 00000000..0d8e1617
--- /dev/null
+++ b/technical-fundamentals/python/coding/problems/34_check_balanced.py
@@ -0,0 +1,25 @@
+# 34. Check Balanced:
+# Implement a function to check if a binary tree is balanced.
+# For the purposes of this question, a balanced tree is defined to be a tree such that
+# the heights of the two subtrees of any node never differ by more than one.
+
+from __future__ import annotations
+from typing import TypeVar, Generic, Optional
+
+T = TypeVar("T")
+
+
+class TreeNode(Generic[T]):
+    def __init__(
+        self,
+        value: T,
+        left: Optional["TreeNode[T]"] = None,
+        right: Optional["TreeNode[T]"] = None,
+    ):
+        self.value = value
+        self.left = left
+        self.right = right
+
+
+def check_balanced(tree: Optional[TreeNode[T]]) -> bool:
+    pass
diff --git a/technical-fundamentals/python/coding/problems/35_validate_bst.py b/technical-fundamentals/python/coding/problems/35_validate_bst.py
new file mode 100644
index 00000000..a16d7b04
--- /dev/null
+++ b/technical-fundamentals/python/coding/problems/35_validate_bst.py
@@ -0,0 +1,23 @@
+# 35. Validate BST:
+# Implement a function to check if a binary tree is a binary search tree.
+
+from __future__ import annotations
+from typing import TypeVar, Generic, Optional
+
+T = TypeVar("T")
+
+
+class TreeNode(Generic[T]):
+    def __init__(
+        self,
+        value: T,
+        left: Optional["TreeNode[T]"] = None,
+        right: Optional["TreeNode[T]"] = None,
+    ):
+        self.value = value
+        self.left = left
+        self.right = right
+
+
+def validate_bst(node: Optional[TreeNode[T]]) -> bool:
+    pass
diff --git a/technical-fundamentals/python/coding/problems/36_successor.py b/technical-fundamentals/python/coding/problems/36_successor.py
new file mode 100644
index 00000000..9b54ba2f
--- /dev/null
+++ b/technical-fundamentals/python/coding/problems/36_successor.py
@@ -0,0 +1,26 @@
+# 36. Successor:
+# Write an algorithm to find the "next" node (i.e., in-order successor) of a given
+# node in a binary search tree. You may assume that each node has a link to its parent.
+
+from __future__ import annotations
+from typing import TypeVar, Generic, Optional
+
+T = TypeVar("T")
+
+
+class TreeNode(Generic[T]):
+    def __init__(
+        self,
+        value: T,
+        left: Optional["TreeNode[T]"] = None,
+        right: Optional["TreeNode[T]"] = None,
+        parent: Optional["TreeNode[T]"] = None,
+    ):
+        self.value = value
+        self.left = left
+        self.right = right
+        self.parent = parent
+
+
+def successor(node: TreeNode[T]) -> Optional[TreeNode[T]]:
+    pass
diff --git a/technical-fundamentals/python/coding/problems/37_build_order.py b/technical-fundamentals/python/coding/problems/37_build_order.py
new file mode 100644
index 00000000..4d40411c
--- /dev/null
+++ b/technical-fundamentals/python/coding/problems/37_build_order.py
@@ -0,0 +1,19 @@
+# 37. Build Order:
+# You are given a list of projects and a list of dependencies (which is a list of pairs
+# of projects, where the second project is dependent on the first project). All of a
+# project's dependencies must be built before the project is. Find a build order that
+# will allow the projects to be built. If there is no valid build order, return an error.
+#
+# EXAMPLE
+# Input:
+#   projects: a, b, c, d, e, f
+#   dependencies: (a, d), (f, b), (b, d), (f, a), (d, c)
+# Output: e, f, a, b, d, c
+
+from typing import List, Union
+
+
+def build_order(
+    projects: List[str], dependencies: List[List[str]]
+) -> Union[List[str], str]:
+    pass
diff --git a/technical-fundamentals/python/coding/problems/38_first_common_ancestor.py b/technical-fundamentals/python/coding/problems/38_first_common_ancestor.py
new file mode 100644
index 00000000..13b1922e
--- /dev/null
+++ b/technical-fundamentals/python/coding/problems/38_first_common_ancestor.py
@@ -0,0 +1,29 @@
+# 38. First Common Ancestor:
+# Design an algorithm and write code to find the first common ancestor of two nodes
+# in a binary tree. Avoid storing additional nodes in a data structure.
+# NOTE: This is not necessarily a binary search tree.
+
+from __future__ import annotations
+from typing import TypeVar, Generic, Optional
+
+T = TypeVar("T")
+
+
+class TreeNode(Generic[T]):
+    def __init__(
+        self,
+        value: T,
+        left: Optional["TreeNode[T]"] = None,
+        right: Optional["TreeNode[T]"] = None,
+    ):
+        self.value = value
+        self.left = left
+        self.right = right
+
+
+def first_common_ancestor(
+    root: Optional[TreeNode[T]],
+    p: TreeNode[T],
+    q: TreeNode[T],
+) -> Optional[TreeNode[T]]:
+    pass
diff --git a/technical-fundamentals/python/coding/problems/39_bst_sequences.py b/technical-fundamentals/python/coding/problems/39_bst_sequences.py
new file mode 100644
index 00000000..498fb6e9
--- /dev/null
+++ b/technical-fundamentals/python/coding/problems/39_bst_sequences.py
@@ -0,0 +1,32 @@
+# 39. BST Sequences:
+# A binary search tree was created by traversing through an array from left to right
+# and inserting each element. Given a binary search tree with distinct elements,
+# print all possible arrays that could have led to this tree.
+#
+# EXAMPLE
+# Input:
+#       2
+#      / \
+#     1   3
+# Output: [[2, 1, 3], [2, 3, 1]]
+
+from __future__ import annotations
+from typing import TypeVar, Generic, Optional, List
+
+T = TypeVar("T")
+
+
+class TreeNode(Generic[T]):
+    def __init__(
+        self,
+        value: T,
+        left: Optional["TreeNode[T]"] = None,
+        right: Optional["TreeNode[T]"] = None,
+    ):
+        self.value = value
+        self.left = left
+        self.right = right
+
+
+def bst_sequences(root: TreeNode[T]) -> List[List[T]]:
+    pass
diff --git a/technical-fundamentals/python/coding/problems/41_triple_steps.py b/technical-fundamentals/python/coding/problems/41_triple_steps.py
new file mode 100644
index 00000000..bc8c4baa
--- /dev/null
+++ b/technical-fundamentals/python/coding/problems/41_triple_steps.py
@@ -0,0 +1,8 @@
+# 41. Triple Step:
+# A child is running up a staircase with n steps and can hop either
+# 1 step, 2 steps, or 3 steps at a time. Implement a method to count
+# how many possible ways the child can run up the stairs.
+
+
+def triple_step(n: int) -> int:
+    pass
diff --git a/technical-fundamentals/python/coding/problems/42_robot_in_a_grid.py b/technical-fundamentals/python/coding/problems/42_robot_in_a_grid.py
new file mode 100644
index 00000000..d17f14fc
--- /dev/null
+++ b/technical-fundamentals/python/coding/problems/42_robot_in_a_grid.py
@@ -0,0 +1,14 @@
+# 42. Robot in a Grid:
+# Imagine a robot sitting on the upper left corner of a grid with r rows and c columns.
+# The robot can only move in two directions, right and down, but certain cells are
+# "off limits" such that the robot cannot step on them.
+# Design an algorithm to find a path for the robot from the top left to the bottom right.
+
+from typing import List, Tuple, Union
+
+Grid = List[List[bool]]
+Path = List[Tuple[int, int]]
+
+
+def robot_in_a_grid(grid: Grid) -> Union[Path, bool]:
+    pass
diff --git a/technical-fundamentals/python/coding/problems/43_magic_index.py b/technical-fundamentals/python/coding/problems/43_magic_index.py
new file mode 100644
index 00000000..e52872a9
--- /dev/null
+++ b/technical-fundamentals/python/coding/problems/43_magic_index.py
@@ -0,0 +1,16 @@
+# 43. Magic Index:
+# A magic index in an array A[0...n-1] is defined to be an index such that A[i] = i.
+# Given a sorted array of distinct integers, write a method to find a magic index,
+# if one exists, in array A.
+#
+# FOLLOW UP: What if the values are not distinct?
+
+from typing import List, Optional
+
+
+def find_magic_index_distinct(arr: List[int]) -> Optional[int]:
+    pass
+
+
+def find_magic_index_non_distinct(arr: List[int]) -> Optional[int]:
+    pass
diff --git a/technical-fundamentals/python/coding/problems/44_power_set.py b/technical-fundamentals/python/coding/problems/44_power_set.py
new file mode 100644
index 00000000..63fcf39f
--- /dev/null
+++ b/technical-fundamentals/python/coding/problems/44_power_set.py
@@ -0,0 +1,12 @@
+# 44. Power Set:
+# Write a method to return all subsets of a set.
+#
+# Example
+# Input: [1, 2, 3]
+# Output: [ [], [1], [1, 2], [1, 2, 3], [1, 3], [2], [2, 3], [3] ]
+
+from typing import List
+
+
+def power_set(s: List[int]) -> List[List[int]]:
+    pass
diff --git a/technical-fundamentals/python/coding/problems/45_recursive_multiply.py b/technical-fundamentals/python/coding/problems/45_recursive_multiply.py
new file mode 100644
index 00000000..afee936a
--- /dev/null
+++ b/technical-fundamentals/python/coding/problems/45_recursive_multiply.py
@@ -0,0 +1,8 @@
+# 45. Recursive Multiply:
+# Write a recursive function to multiply two positive integers without using the *
+# operator. You can use addition, subtraction, and bit shifting, but you should
+# minimize the number of those operations.
+
+
+def recursive_multiply(a: int, b: int) -> int:
+    pass
diff --git a/technical-fundamentals/python/coding/problems/46_towers_of_hanoi.py b/technical-fundamentals/python/coding/problems/46_towers_of_hanoi.py
new file mode 100644
index 00000000..a49ca9d9
--- /dev/null
+++ b/technical-fundamentals/python/coding/problems/46_towers_of_hanoi.py
@@ -0,0 +1,20 @@
+# 46. Towers of Hanoi:
+# In the classic problem of the Towers of Hanoi, you have 3 towers and N disks of
+# different sizes which can slide onto any tower. The puzzle starts with disks sorted
+# in ascending order of size from top to bottom (i.e., each disk sits on top of an
+# even larger one).
+#
+# Constraints:
+# - Only one disk can be moved at a time.
+# - A disk is slid off the top of one tower onto another tower.
+# - A disk cannot be placed on top of a smaller disk.
+#
+# Write a program to move the disks from the first tower to the last using stacks.
+
+from typing import List, Tuple
+
+Tower = List[int]
+
+
+def towers_of_hanoi(n: int) -> Tuple[Tower, Tower, Tower]:
+    pass
diff --git a/technical-fundamentals/python/coding/problems/47_permutations_with_dups.py b/technical-fundamentals/python/coding/problems/47_permutations_with_dups.py
new file mode 100644
index 00000000..b1a46382
--- /dev/null
+++ b/technical-fundamentals/python/coding/problems/47_permutations_with_dups.py
@@ -0,0 +1,16 @@
+# 47. Permutations without Dups:
+# Write a method to compute all permutations of a string of unique characters.
+
+# Permutations with Dups:
+# Write a method to compute all permutations of a string whose characters are not
+# necessarily unique. The list of permutations should not have duplicates.
+
+from typing import List
+
+
+def permutations_without_dups(s: str) -> List[str]:
+    pass
+
+
+def permutations_with_dups(s: str) -> List[str]:
+    pass
diff --git a/technical-fundamentals/python/coding/problems/48_coin_change.py b/technical-fundamentals/python/coding/problems/48_coin_change.py
new file mode 100644
index 00000000..4f84b963
--- /dev/null
+++ b/technical-fundamentals/python/coding/problems/48_coin_change.py
@@ -0,0 +1,19 @@
+# 48. Coin Change: https://leetcode.com/problems/coin-change-ii/description/
+# You are given an integer array coins representing coins of different denominations
+# and an integer amount representing a total amount of money.
+# Return the number of combinations that make up that amount.
+# If that amount of money cannot be made up by any combination of the coins, return 0.
+#
+# Input: amount = 5, coins = [1,2,5]
+# Output: 4
+# Explanation: there are four ways to make up the amount:
+# 5=5
+# 5=2+2+1
+# 5=2+1+1+1
+# 5=1+1+1+1+1
+
+from typing import List
+
+
+def coin_change(amount: int, coins: List[int]) -> int:
+    pass
diff --git a/technical-fundamentals/python/coding/problems/__init__.py b/technical-fundamentals/python/coding/problems/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/technical-fundamentals/python/coding/problems/__pycache__/01_is_unique.cpython-314.pyc b/technical-fundamentals/python/coding/problems/__pycache__/01_is_unique.cpython-314.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..7adf4fde93da68d21df5de4402fa5362c2011e04
GIT binary patch
literal 596
zcmX|8J#W-N5S{f!ce&*5F!@jbMGz7Z>4d^M4GL03844r>79>rCwXrwYVDFmUb)xHB
zP(*@~l0U#dIxQs?T~1d-bj<olo;2fmZ)V5q=f{Ko0wDC}-z*>iza6=T_rI7fVNpW}
zYY>t($bAE$w*|vij3>Z_!yHBnV;W$p;Sk<?dtU$&)Yjn*Nl8eKu`@&H9baz;+U)w{
zxFy=Q6*rX<L(jIfQFiV`%6v#{`&6oe8SP%TX*2pxbEPRN*_o!VmHfzKqv>uCe4?2!
zT%Be7d`EGXjHuypDzcd6JExUMSiyy1xu)gFq*BmWCYks^OC?WoUT7NZMwyN(k$tZC
zlX7HxQN)Chh8Z43%DL6X(DyLaa0PARPh9%GeCZxPRvI?NE;RPI!r{iAr$}m`P?AIN
z;lKwdy`zWEP)%@V9Uh?3TWIvr(l%-@(fcmkM~;Sj2XB9(?aJ-4os{XcV5KFocD`?K
zY^bhlbZ@S&aQW=EkFcm=Jn-umzxsm<GG6R`+qcVi#;bQPI$swi9T?o2%tOyti#Yje
mNSdRnkEBs%o9FinnN&G{u5M$){R!>-xNH$Zu6p?O&FnuAZhn6N

literal 0
HcmV?d00001

diff --git a/technical-fundamentals/python/coding/problems/__pycache__/02_check_permutations.cpython-314.pyc b/technical-fundamentals/python/coding/problems/__pycache__/02_check_permutations.cpython-314.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..0cc1569f872095d5720fe684f36c6803dfdc8ea2
GIT binary patch
literal 947
zcmZuw&rcIk5T5t8w9wxHBZ@={O)!nXwuJ)*Vqzp<AVFwCxsW!?cCnT1?)u&?%B=?v
znApI<0|yV9m>3gp{ssOAA{?6arYCNYniy`*+qT50lgxWF-^_k*-pt$E(MS+b_{c@&
z69M=koQ}}8(d<Q|207@59O(x=ZbObHAtkB!1qc=5N0m^Uv$)hC4+T2?9H4~QAgq!y
z$&n3=v?NFWu%(U8Ngzwe>pK;`OL+!0>-w2yJIqK?SK>BveVeAKr-<v{GFerzxj28s
zW%3%=7?%;L>~ML7nU6Kq=5i*T-j*wdt+Abo_H>+SN@-WNHMMM1R7D@(a*UEv)eKwF
zxoqv)Wz&#Vvs5u2$rdv=b*;+fbhfCLHFdjaX{_qlcz|i}32WC47mJEvn22b_A`4+1
zU8sB*mm2(n2$?(=%j?NAvAw(RZ6D`6u!%{aUfvs>0IJtN(a{>nV9`9pVIJu$X+3)f
z(Gv0xLIKv3qnNy&oS`#xYyi!+6v$YlV*@ynLq*<F5}*feLY^R7qRobQsb8@Dmjxpo
zxnvmv7{d7{J+2L`rX_j0BC7sNrrLfS)_e|~0Ef=w{hrJfVEO^TGF|Fv)#OmiH`V4!
zV%89<<*Pu7o(hI}F?2=OUH^`vI~q@QF(1NA^w|xR6<)3?mP=HZJmUfz9Ze(>OuT5f
z_urYZD;V%b#L%cgBO0$Qe2c{PNFx+J3EgO1AJ|)XvDoO2?FSE(daNEi4?r~D4C3PD
zyqs->`}P+PhwBgPi{JaMo%dkmXBfh<H-Y!jx6zYC`Z$(3N~8}n2dl6AXdJ~d$D!;O
zU-sf_EW^bw^7&Te-c0v$ig?w002W5DRdV-i)hs!>c9&g6Omu~dtDH%MkY7Q3LSF7~
D?$W|r

literal 0
HcmV?d00001

diff --git a/technical-fundamentals/python/coding/problems/__pycache__/03_urlify.cpython-314.pyc b/technical-fundamentals/python/coding/problems/__pycache__/03_urlify.cpython-314.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..011401cc138347a7b78da9ad753a608539f74229
GIT binary patch
literal 627
zcmZ8f&ui2`6n>MGZMSCAHXsG@$5K&Pv`(s*J(M2zQq&sg>Ol-KnRTPtNtl^!Sx-55
zkkVog{uBO3OS}l4ylvS-@z(dUir@$D&G+8CH;?&d9=NSlK<KUC=@$m@lY+mn{*bwc
zq=W!AAz+)3ts4leyU?*?>;N*t5}J)R_tBNmhc{OD6F`EwoA81SS-@W7&H{n;kMsJh
zUo@>^x@st4#!7ZrWox5wX$*2Tij1Z~Th)LcYN0g8OnRjGfy&>D*l51v`yY5JjZjCa
zINnwwN+#Thcqr32%C-k%nM5NYO_XU~Ow2HsJkFC;zT<_;-)3T@x&I^_t1KN%9u<?y
z3ByRr+(br%p=#pnWi)*QT?v=4%)AS7r}2!IuW=pCaTjV;h!9ATT9pGNq+!AOunxUj
z0EN}J0@i(n8abp<p9R*#7BwwUu>I=*FTMYAcL17j8>{IBDwM4K(Z2WC|AvuT!p^D@
zNqsC-#bQm9@3-4(rOq!dr#3LC@4}IkFm0`sz3(meGn-y>&h69g)bY;6+4Ga$563&(
zKj~dG!CjlJg5#A>75$cH9abNrTny^WV!+DoC{M<j*i-aj=(#kN&uqrnrHd-nwO98v
BgCGC^

literal 0
HcmV?d00001

diff --git a/technical-fundamentals/python/coding/problems/__pycache__/04_palindrome_permutation.cpython-314.pyc b/technical-fundamentals/python/coding/problems/__pycache__/04_palindrome_permutation.cpython-314.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..5c284c07429e0806184920963b3e9179a3726ffd
GIT binary patch
literal 795
zcmZuuOK;Oa5T3O|UwJelg%l_#DpI8Y#fj8IkfI)mpa>NUQY5NauDvA&+iP~6RJr-U
zq2VEN<iL>&|AqsH;9ih8^_D7!iW{>IDMDhTnVoOH*_qWhH*?tqKohIKoFfI`rvy_&
zoY?q09ueqJ1f3MY&4-{X*P*Oh1PSTVQs^rBxPl>qCbX2=YXBSXR^Sn76P@fLGcjG+
zopuK;>2)k|Ohi1xY1rX@S&3B<@;J4}m|G_C%s%6u845XWHSTIp1m!}*8>cI@ZO&d$
zD->F_QhBL4en@%Op$F@nns!eMsnzx!%XHWGJHBmt)DKNpXhAP*Ghefq?fB2NfU`Z9
zdP1vg7=h_JzRj6Ojev5m6XF!+-wt|l#xP9ZXLvykgG=c$=;AVl2u>kOmQQ5(WR2wU
z*-p?HSxB^!iL^7VJ|c)fgMhRkP@0g3yLEs-ZK~T-U6Tisu<<9CyiRIQr|NF40PIxn
z;0rr1)z+1r!Wz~#l@_^`{o5c=wyIcJn42)gf0#{xdAOD^wHp9(zsIs5CZ)%y|2dZ(
zP+m@P`S*CXZHl&M2Jx)LI#TYKSVA&urBaE{%aV)#SCJQxOhkKzNd&`OK57hei&5h!
zn>!@KO!h;g-*|fu({yH_zN>xDEMfL7ePwv*>S3dQf0!u@UcG<trtu?R94wrnlLF)x
zM@xXL*{^?16?q!_KP;1E;1@{X<Y#krkJ%lUZt@FQB6SvWlOvT7a=MIrOKN`u)JU-*

literal 0
HcmV?d00001

diff --git a/technical-fundamentals/python/coding/problems/__pycache__/05_one_away.cpython-314.pyc b/technical-fundamentals/python/coding/problems/__pycache__/05_one_away.cpython-314.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..e378d5915a2f6ad7b0319df6fb96ae7c55d5a97f
GIT binary patch
literal 1207
zcma)5&2Q6K5T9qqaX*sQ36$_r2umcSh!(d6mVgilA$kCTAX}O}RE^xkZ4HiX-gDZG
zgdm3=!befGTUI$NH!j>b@elAPfRK6Wq0(~M8&wa88}r<{WN(Z#Z$3RUzscmpK(Y^z
z*s*WcTN&VAVMHYDC|hY%noxuc6iEhb&4;3tgS=cJ7!WKdj*Jyx>jFMan1)%YumVs;
z-!R-Ji=;?qFtSZWsY{n<qE4X8SU2{cu(`y>ktcYZntq)+d5O!+r#v?2x^|xM_`FMN
zhR;O*V|-D+!%WI_^jJ$wzeU}<X2oav_}JJz-Ew@BE?MUCC^e00L-)<fqGMGIdvw0;
zRE?VH_=e4Nui-Dcj$U!Amb0LH)Sa`<8q>$llwHRx8_P!Hq}Skya@lYk*Ef8#T&Dfl
zT}5WU;M0V!kSD24@vL3>BE&zxh2qsz=-k32sO+LeLqQI=_6Bh@p+pM5M>{J*4rZe5
z;yzFB=$_Q&CA(g^lncMTB=$WEUTj9x4QX16vNV`H0pKYmW#nKK1t<-5TZLtSh45Fq
zz8_#ZHVcI{oGB*iX7K`Y!be7uKfd>3*GB<*;RxOc&MYv6RLYHn*R^d$Gt82(Uf4lY
z!?{I$yq{s1B3^t7JoQEl-#A+8|B-Ydk4N<)iP$DWY-Tr_Qhho$vNMkm-LWpD*`G#w
z`UldyG&Px*xon#bSE%7Em|QmISiXnivVe*`@Hhs`c*)yxf-6;Pex7k+afQ_k+vf6|
zwZM8X_4x6lAyKh2-fywpv!faGgje<sl_msg@5&#a2KRhUYVGvXQgd=WQa04&2Q?FD
zsg|;y+SgwC`*7=WFqm4ccchof^M}En{hjf(bNtZJKpX0$UiAH`Z1zGryV(cY-p^`Z
z>(|vw@6|&c<Aa+0qzz%Ul}CY=ZYjZl_E_H7(OU9GBH6sUo=mTuYS;fd|1o)_MS^~9
zwa{jrJ1@_^c<`}57Yy!g-+$KNnc*OjYTsVH_T(zI8pv)YAfeF&;<%Y7A+XmFn%l5@
eF4Wv=-8L`M1DGN%o{4pQkqIGR2k;LS=6(l-`0{`N

literal 0
HcmV?d00001

diff --git a/technical-fundamentals/python/coding/problems/__pycache__/06_string_compression.cpython-314.pyc b/technical-fundamentals/python/coding/problems/__pycache__/06_string_compression.cpython-314.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..bf60ad65a3371a6891c22ef6e1b0a6fd8d5ee6d2
GIT binary patch
literal 1034
zcmb7D&1(};5TBRbq-nGHXv7Ar4Yq+wFm+QXrGg(+Fa@ik0aFhlVcl%g)ns>lZ_`q|
zEa)Lr3xQTB=+TS+gMWsRWf2tg(p#m6;>~&6EVk&yfq64;W_D)YZ)Ptg;v;~>rhe%Y
z0>F2E2`DsB4%4VOP=*YYNd{Ue8_J;^<OP+WgEJ=)88g6P5f29{Pzx=*1Zbe`JUk$4
zq)e*lIi_;xk1qSU_IWjrFfT$iyF-mU@dRd56p>YvwiTQ4LQ@`<A2N+H87=xclkZdW
ziKg02o-G!i%DQ1|bY0grW~in#Hf38=*9=`%S~II1qoK4l!&X{Mwl?iG(~woOp&L!v
zqUPh4)@E{XzK#{qR9DTmMK#8B)3|JHdQ!cv7=~#pwpOpxVeEr5JBNn@N027zpZs{2
zJK*Ad&c7X^7kq@c!YP96BXk>|!V$XYn*o|WMit0GH9!-+a|7KXh$R$wwE<b78nJ{j
zvBWCR=TnXR>)W}(3{z0L24IC(!YA`oLJN;@LK2@)MW~TNJjjNz!tyx4%FSvxuvLVh
zqe5UpdFmVSbpGQ$mv3;qvj3gy#Cyb`a)m5>40ej+RS|IyL;JiR4;RuCTAJa7sbVxW
z%HhsOsK|X`wAYzORBuQ%JA6yLh+?n}ltgDda{2-%8s*XHzt@1CMTbB29aJ3n8k5{)
zsvG?wC41ym$+_i5hr5&8qO<5GlFpJFPdcS9@pNx?SKXW3S^XTJ=n^+3ZO`>)Ute*h
zGrecqcea+kNw_q7&9{aA*mPf-?v~ut=o_)S=#FK!mVU+|kv&L2IJTSXHFpaAM7A$x
zG40SucmBomp7v>I-0#7SjXHNJ|BvtGiQni4@UO?OiC%4+jZRCuPBR$7mx}S&1A!27
Kl*WbiV}Apm^v$*a

literal 0
HcmV?d00001

diff --git a/technical-fundamentals/python/coding/problems/__pycache__/07_rotate_matrix.cpython-314.pyc b/technical-fundamentals/python/coding/problems/__pycache__/07_rotate_matrix.cpython-314.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..987da6b4277f56f20005233bce6708d3f1064793
GIT binary patch
literal 1411
zcma)6%}*0S6o0eZu6(oxDvC-Y7AT<+Tq+nn7^5)~i9n#yHb$VX?P3?(?J_$>x%J?o
z#?<t(Ne?#Z#e@HdcVkep;b7v48>S(|#Di~kX>2czubJ8R@tgNG^Lpj9zXy=ak>A=M
z0pKSWnk1eujoZi+VI5**9v%=zhGC81Pnf*egaWkkOpFPG5EBO>+s8aH&nQH^2OJt9
zwr4>zS&E>*7bg!c9;z{cTM^>0F5G+rkVah)R!D}#$SPV~iU~1M7SN&R0Mi9q$|;O$
zuWgB{tU&c8j36yKD$Z@>DcVgQX~fRSk4=@DGHSGKQ(mU|O*O?#IXXT4Qr2{)(rrzB
zHAPh=y(2R<mC?17lAYQp=xHUV>P*R+va!Q5d0kHB)0+N5Hfa8NR?V66^o=CVGli*1
zH=V1-j_pe(6<v3=N!p7k^x-mj%ZhLey(IjLZy&}F`KSKKks4?Pr#qbCB;j(pa}Db)
z!fLZ?*r(YO-XN>ZtAaRL7bbaUPN<3LgSjIBL->bGgyO=abNMcGowQ1`CqD4pE}jz;
zZI>MvTd&*jB--Repw&~m-?nq!1nHDRD>iZFKYdE*Q~W<H#%_7Q#;JtSu8E7|*qX$h
z_G&v-=irw+AzCALs>$*6tP`TuQ(WNqhu;CZ;SxMNcE2%#b0SbLnwBDhEoN2S_EJTE
zp+>r>gj$>EHqmUdX?r&`YBF0g)l^<j+g_H@XqwMYfwGL*h1l`SE>ZquY=7Hxr-P_-
zUiW8Yim>0+Tbg^<TfDpP4^*NR#hQKpv_$s%&sDanN-bOu)gs^e$4Yni1}<9jRmEB;
z-QPPqWId^F)y#UdR@gloF3q8_x>B1#-F0iR9{M<1S3ZV!2PPaWy17>;wfojuJ?f%|
zLX~KFzM{Nc*c%>mSu0fyS?U*GaBnnHiCQz2E$e!Du^Ot4@+`jiE<4D7`merVqaOm{
zh6txGP#>1E6!F>;+c9w1DIYOg#QzD(+u@Y_2^^H$lCE31e7cZTZ_^>P^U*YexE+dw
bkfR<T=YMqjOX<o?St}10rQ-k&y>t36Dk})t

literal 0
HcmV?d00001

diff --git a/technical-fundamentals/python/coding/problems/__pycache__/08_zero_matrix.cpython-314.pyc b/technical-fundamentals/python/coding/problems/__pycache__/08_zero_matrix.cpython-314.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..2357e3f243cda72bb458e976080b15d6a572e305
GIT binary patch
literal 1678
zcmZ`(-D?|15TCs}U93bOmOq-0x|L!DIm*}B!~}<yKua+-c1&_KY9Abli*&LtmhR-e
zvs1O9=phe+BDf+K1Wh2X{eOy34?h%I2zg6Tis@Tt?@p1<vFF&^+1c6s&2M&gug0RM
z0mYpCPy3Sx_?ry|f@4?ucd%<f9%QltUlWTY;UU3~yLQ3%z;0Bxc$qs3GJh5-<CY)`
zX~>3NGuJF}gf-2yiUbF&F%hsasQzXAH6RChZs{3732ifQpKKACY~YM1GAHvAhZ_p7
zIkY%pRk5h{y(3c9+NJtBB8Ycg6Vu8D#d(t<%{trC15>4@gcfbjl<raEv0AiDX<>eT
zTheq(rF)wC<T_QAQeCpt;+C!zmCE(<u3l2As%|M2Q>xXiEkl=zMoH5*r5ZIJRn)2}
z%`X*xP^nSyg1J$vJCQ;`(RIU8EVWReXD|SkXOktY0f%sbeDaq4o{Mi-_j1u4^>G&5
z+%Sd77&bRI{~+52$WSBLxQ#*XFk6eho`j9Tfx$+|U5&rt{J?J<mWu#2{y6V%`O#w>
ztQhpT@=IJP1if;?=$bq%eFw1Vp55ws#OFPWcbYP(k(_YE!sQ{jV;(XXd7f25psaEN
zv#)*y5Qa}-RrUHIk32b+H>(pAjJ_P?J?bBfV8D2BxE4{5G7m=Qvx=~)J<7<7{6jt`
zX6`oQAB@RozwEQ$^7<T^^XNfIV#vd6jOHR3>3ep5<zQywjNOSDPxx5ed#voqSjX%h
zV|hQy$2;ZKac^%K?=)*!e)*gAEboMB6tAQcqKdw$I($Xdvmq)XRVQ55sA(0b@x+OE
zYSF0dR&|GH4tZ>{%Fm=wD7$dZnUQ-*r_thG!z;+V0lo3*#!7GUTx0D(2sbm&?jA%Z
z_HWvI?a#W=WRn~uKH4`sw_e<C|I|%nnqTzd)2(_Z(R$k1>BdvN$*B(6ztu}!vT+Yj
zPtVzFy=2N3e+_po{t|Ijdxs6$k$xN|=HBuUOTC+d*rdI%U+iSs+ui7_i)8OSPj|{M
zwBK%Y6WIXPABZ)wXMEaLM#C6PAwn1?t}ul3VGPC+e)umh4heib(_FR}S}V5l^BOu%
z%)L4_>ASUm>?YEP%UnE%J~~`NudykLH4W?8kRw|48oqm!y)zDv=R?{1<fip^aJ{^w
wk9}S>O1l;H4#gM1edo;?RNnA}kbh4DIrmpM+AP^OTUsmG5D!Is0o~RA18{aW$p8QV

literal 0
HcmV?d00001

diff --git a/technical-fundamentals/python/coding/problems/__pycache__/09_string_rotation.cpython-314.pyc b/technical-fundamentals/python/coding/problems/__pycache__/09_string_rotation.cpython-314.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..44cbf53c572bf136ddcef4cc2eac59d204eee323
GIT binary patch
literal 644
zcmZ8eziSjx5T3Vto}zb`NQ8^v4~!64H1{qx8i>}h3A$ixLYBSVm)z>!d&j)Dk?Xdw
zv9qxgD;vQ-#xiVcl`e8fuybbD6LDZ>zW42WGvCbK>vb;!nO*ypeG&lQ`LHnW518K~
zP{IL(;wkJ1CvHRN^&#~8kS{wgY~6+6!YN-4MAgY`WQ&n?nCYX0N&-7uo7^X#Z&N5?
z4-ULXZvj%`ZoqRf7NOXuFO7xXKiJ=2NCD|nv(_n}E6;9{Kd9QMT!A|9Dxca`t&uS~
zDQO=XoW#y@|Fz1<7gnK_#AL@-K11_LCC<vt;qbN0v{QJTsW%&_;&djRO2#@%;(X(<
z&}lqT+Qqq*)0rC^EfbT{Y;uZbl&guA!>y<pH$vm6ywQW{tm;HjtThuVim*!}c+>U{
zg%Zv|i0eN%eDu#aeO{^4*K0L7r%RCh9hwfjxO#c31WI@*_QZWc3)><<ixInDAn=ek
zjTb3cF0sCj9ZJ>Ge<JZJv9+ciff7!xbl;CY^xr-H)>=iTb_2h<*$g{a3_B=XmfJy7
t$|6gu>)<jYe$_O)v^_Ctk*g=TLLC1ByF}s47ef5(fp~b{rm5=(zX2n~kbVFF

literal 0
HcmV?d00001

diff --git a/technical-fundamentals/python/coding/problems/__pycache__/11_remove_dups.cpython-314.pyc b/technical-fundamentals/python/coding/problems/__pycache__/11_remove_dups.cpython-314.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..5844244d9a2b727418b0292cc401cd7e15607bfd
GIT binary patch
literal 1318
zcmbVMO>Y!O5UrlC-Sro?z&L;v0~WScU<L~$B7|}Q2_r>L7#TRAb!(XI#RIcFOLwnf
zIjxikaeyet`~`joe*kV|E>V;dH=_mlN>$G+Add8*rmCyw)$3O^b9!ca0&u-r{Fv4q
zfd45Nub_0;=sr3_*oKH*hYe=f68X+`XTvq_hG)DD-}p<=a!)|yUSQ>0CYT3|y#<K;
zme&f-938^~TyU#1wWtx*@I-w9ve}H8dK4@}bK)JPo2;0OrOZui(p>7MThz7&J#i~m
zMeUl9LZwMj|FuWSI4jsz@&zBDD!@i7xI2Uv7#4wXwx^97`H_Pq-KwM)dB%?zmJJGT
zGjEH{gl<sX0zC8)jE#<4pj)u*{PYJv8}}CB2HRl~i=4=fywE`i{~c-wg})nTeW7aP
zdr~|$PY#ZW-dUv@ceYxqt(SDgpp&a^Y&6w7Sv&}DYN2$9JL#?te^dE=kr*AWpF8&;
zOr;TOHx-Z8l!)7d(1>J5rb(Qwb^5X$cZD=@ro-OA?Bp^`@^&ikg*}zu%|sU=*0~bh
zd{^*xzo*ak2E`QTmA-=WVvcy7{d#K#Dd}TqhOiHgf8;%xzvDf6yk5Oz!x5$-snjMP
zNC1o*qaV>3!tGf}yLR0^F2}M$1k3P}Z8jY>g*i2i20QF&k#)Z8XaZhYSy8k2Eb5%6
zGBwC`y5d@fmM5VM;qCm<=M!%a{qSc)9VA4@0+)dEv=I=BM6D2Ig7a?P?q}qq77zPz
zR%H%w-bs}<St^ChIado*f1Yzq!<g{c7?s}b8=)~r<!v>~QZ*<fLs!y7>nZFzDA|Z~
zD-Tlo`^L<%W9F$zL@2x+oP#HGpGT{jtX2^yVfsp1YE7mN5EDCKCB-?66&cb<FQTCi
zGuC)d=Jny#J^MU=)y9^x{U-3BT?B=lVI%rM3~ehFsXMN>gubm;HE!~&!BZzOY3us-
z<$t_-sfle*gPPLmBYA9!qV5-g8T4?Fm4|_%cNA5%-&UzL0e;hjqJFvT?9b{HW{Iyp
xk7mzhjD4H|w)`)wy@9p=yvb)*e*b02J_Ig1^6cVY>n|>S0Ce}K#%fq{p8$TR8;Sq`

literal 0
HcmV?d00001

diff --git a/technical-fundamentals/python/coding/problems/__pycache__/12_kth_to_last.cpython-314.pyc b/technical-fundamentals/python/coding/problems/__pycache__/12_kth_to_last.cpython-314.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..9fc4a1bcb08418afbc91ec6959f34974f20a1bc5
GIT binary patch
literal 1337
zcmZ`&OK%)S5U!rr?)s6~N-UEQVG~ET7O*FYB7p+p!U0D@21ZVDh}NyiY;Sh(xM$Pd
z>##nJ1VT9g%8?`2@H_Yc;THOW5U1Q6Z6aT(>e+>Wls;6~qvxxy9`o+0`5D0T>xGy3
zFAU%>GNvc06*lgnQo$Z1>;`Nz!&XT5Zg|_i@wWpLY=<UXfsX$+B>pu-p<|*YKs#85
zB<uv8=)Lo`pX4>a)=eXcFy2^(V!<?%<{GqH&nVPpb~cr=G^xo;soTD7?2ZQFR;p~{
zQz3=QGu!-pK*6-IY&Wa%YB>RC<8`zv=zw7f7;kUJ_(_;}n9!$$1v5bsm@r|OHnPD^
z*%dn(v7b}`0qO|G#;XqK7VLQ+d<)P;-v#)R^;yCaFY%Kg_7Ea`=HW9N9;U@ms0QhQ
z6knU8GgG2>HYmrP-OfhmF_jqgN_CJLP5Ca`{rIL9O2_EQ4|V*7D!&q$(eahbm-pjb
z8letz@nBPlv^$E8$oewR(qgkWl-=||NRt*i9*j)ClyO#eb9pZwsPb+h4iMrh-#2}3
zN?xSeYz;<sj`K->1?P5=cx}Dvnng<bO%xTJfES*7PU5HZn64)q*PS`WFl3W%lMd7X
zv|Ho1P^sYdf+Vjyw^!w~t&qSPJZ3v>Pt9RW&7;5x2U--pe?6Lj*Vot80^YXCc`kE<
zT<0fTYt!*0lnS0Mo&SF3>Df1aY^gJZ=sDmTaETldp-Ai%qReo9P<Dp}>DY_=!?c)0
zPIKPNl{Q5#g)BK&%anhKb4|;b@zfZV-yIsEF?I@LE}LViT4a)-e@YXr@8HD4mW`=z
z^+O8(XUpg>!&=$+5-JtEe#>xqqu9qyYbYw)27O$GqsC;XEZes}u8ED5FheDe7XMkh
z$%~Go+h*!CeqAqJO?we-MS@zbFQTBSGuC=e;?cchx_(}B*OPZXbY53XMgyN78n3H^
z3aZ?Y74^N&>ZujdS5avCYC722R~A!I2ONhGl?r|jnl8;wyF~-*4Y4j9n4-<Fkr@qe
z$yI=cqW6mOy8o`81A+Z-K(_f&J@t>(21bdo-a>KgGsa#vfvx=ko4>*4pTX?IPrmuA
aVlN_}oqPEHqbomLe*vhT%wZ=Sr@sN{AR|8j

literal 0
HcmV?d00001

diff --git a/technical-fundamentals/python/coding/problems/__pycache__/13_delete_middle_node.cpython-314.pyc b/technical-fundamentals/python/coding/problems/__pycache__/13_delete_middle_node.cpython-314.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..9e541d1d5a091f23f6a8c94d2834ceefaceb8cc1
GIT binary patch
literal 1358
zcmZ`&OK%)S5U!rr?)s6~B*r8}*ol#?71)y~k%%J1g#)&P42(>Ch}NyiOfMdo?OD2e
zP1dK8Kqv=59P<})<0o+B7;a%M2yx2I(I)bhs-9UwK=h%y9z9=u^_aKL%+COxUoJh*
zes%!<Bx8DlT49quDkU61#CBkt8MZ>Yv*T>L#@+Uex9uB$1$ypfh};{j{>lVPfVQ^`
zk>B%r!P^(7umCsQ=1nUKFy2~*e8IG%_8N3MPbk!7)od(fVPcaNQg_{|wKpD$+p(%z
z9|$Q_mQ?MJh7^qRitQyYumKuyHd#k+2|X|@0^=Mk7&r1G2NSxKFlWY#JmW_U(*~8d
zTclz)A@)rL;GvFSY_e*BZo`3d^BaH^eV5=9cE}<YIguNAp@R_q6YL*U{!yHdglduQ
zNpa5{pPLfBvq3rT?DaN!52?hUU#LNBH08Tesqj-Rln&989qI66ReUZIqr+=guYM6`
z(g<~wiLW-5h|_UsL~<yzB+fVcBbmknAx)g?a5y%Hg$$D-&E#j{P!)G`F+hmxJQcYx
zf)BDZ%>|dpV{16B<~VQKEI6+giQd*fU5m&}zmB4WQ*itXPf0w8Pw0BIam$($3`5d1
zophi+pxv3gfl3Mc3zEF{?61mccOil`c*u6Uj+(=mnn!_y_O!_RFFcxn*Vot80^U`d
z^Gs$2xz0CSYt!;1loB2<UHoq5@%h(&=%{mq=vd$yaETlNp-5~QqRenUDAEyjgi|lR
z9L0GPIm>xJQ`+R26tdu4EmQs_&Nc01!ee7pc6Vfi#@HE**=&}j>X1o-IBTNyEu1>o
zvI+IAen{b$mW_Tktd&jPM5ToPUpCy~AarrzT51-bR^B0Q#Br-xt*SjNbVff$<>Jy*
zff8n<<niL)OV~W@S=L>q&LT*?f;D^Ur6Tbv1+Ji=;WO5GO5(x(30*(A_Ih-4$9io|
z3C(?aXv(%6s;jiKR@DAFtD{y(UqzwmtLc1S`R|%4>W8J`qf)|eUfX8d?RIE<{SlUj
z<5RRJRba+L+<fJsq3FG$^!8`0r$S)=8dueRx88yG)CNY0xZXl>;xfjbp9i+~J8b?6
jn}2w-_uv2e!;(D<Tz299J3n6g{?;=<^>hv!VmbW<O!6!O

literal 0
HcmV?d00001

diff --git a/technical-fundamentals/python/coding/problems/__pycache__/14_partition.cpython-314.pyc b/technical-fundamentals/python/coding/problems/__pycache__/14_partition.cpython-314.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..29322c4ecdcfb09898a27ffb9b668780856e24fb
GIT binary patch
literal 1325
zcmZ`(OHUj}5U!rr?((p~HpV8F!NCEo92k(05?NNHD2IR)ZJZIY57sgo&-R9~hn`J$
zFJ^rjDUszvV&#~h5dKRJ<mSvJigMxxS`f#is%O{Ok=zp1_2~KPtH*NZ!uSZ_`TfRe
z@~;K(4;jPbl?v;(QORKo0=5C`OtV?itqp74*7mxiopo2cv(U6}L13@3@+<940ou+q
z1a8x5dLPdWVFA|c!JA6pVZ1U8>4dHZ)p@Ab4k=V;#b_i%rX!tXLe=e}vf1nK2azl)
zUvj}^5*O94I~0u4f^Ej<*Z>1?)?Ywx4o%Q30BvneYCCWP3lrLuFlE{a9PI`S(|U!|
z$XdJ+6Z=60;Gm9RtUqUf9>A9M>5l*{^xc4O*ftATU<G#I_!dIAhuA+T+}$Yca#<nW
z5qwWSzdR)RXpwR}+H5X1_o+m$oyna@E6Vp_k@(*#E|rg-WLNq3W%h)}TKTIhD^LAI
zXfAgX{%lF|sMYf|kGDk<N9j_#D_YSG7dlFn-|6Y?O!#ruO2l`5M`n*xzJm~JVJDJ0
zp?)oQdc{~64!X<3u$UxP%Wu0bAtChviX6_sa<3ng_%%AB>tOM&G5Z*Xc+hLofyzg_
z*1w5L4i6^;dChq^Cx%Uh0OnzzHR_fe!<ZaLf%A0~Puu4nMZgOS3vvSQq8f&YNHlUC
zA8;*A!;?^Qcs(`q)5z;9*Iw1+WkR$Ja0xg?4v$a-b_!8O!f+>RbyL!@7vFcIbP%~1
zhV4WuohE{dEDYr|<(~>eMXMNxk=8PK+|^uR>;lG2Hp5cZ$Rsg|e~M_mfHMnQ)~CLe
z4=Mc4j?r%nYi0f0sO0ee9i!FtZCX`1icbq?8yDgE<eS|ZtX8vNd*$+ZlIyM%hGm_}
zi}+EwX(d}CDM?U;Y90j*o3Yw4iGwR29nt;UEpr{Ld~V#Ph?oXFJTz9rp9;y%a3%G-
zOl!$m(&tbp`f51P+M9Khl-W>lQOV&?r)rWk>NOfuyNfm8m?Y+a!qdGDF1B>gkn~<s
zR#R@-eFFR6Sc>Ysa@L<o`hP%t)iR1Bn=y8J71;b=u=EEk{q2mt{NjhNa(3d`?E1@3
Sep&tb?g^lJHimsLoc;qGULCgp

literal 0
HcmV?d00001

diff --git a/technical-fundamentals/python/coding/problems/__pycache__/15_sum_lists.cpython-314.pyc b/technical-fundamentals/python/coding/problems/__pycache__/15_sum_lists.cpython-314.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..1496bd267fe3663e840a21193d6e10c2649257ba
GIT binary patch
literal 1230
zcmaJ=OHUL*5U!pVyF8Z&B7zD+mTU|R7)>-WoZ*5xiE=Q|8D?i?bhc;h?nU9W2jj_j
z_Al@g{1tj6lbD!z;<lR&*{fAEyZAU*$y9$;)m`toGd?y9NMGkKqAv!(PZ9=X<$!fJ
z5wu_*Jhly6OtV{rjcsGg)aEUihDGqq8St!o=z&OEo{h3I193^)-p~?M3g={~uyn*1
zBGJB%5}{BmJZ=#5<ACe~GIPMXWdtqQ1I;|p#{PshJ=-(TH^z%gF~dj}Mqn7hNv)lv
z8tw!P-_S=yC7?6bT|m%+=df=)cn?rT-8?*Hhs<N1;hCQ08tB44rvg&@$d8+0YDPk*
zmI&YJlhPo|7b_HFW$%<qacYUI`&v=3+iB!JQ=wEYYN8|MK9R|*Fwn}~SYLnbqN`9I
zMd9038T!>@SBJr&hyp)etu;l}uZKeWv2q*7`Y;i0kW?e_(rw7(AP(#3;yzc+I*%iz
z)mq~?9p${=#gOxKl2TgxQ&qx*)Ld3^4-9*@L+o?VrsG@XVJ3Fb3_-uqgn?>Dx!Apl
zpar`nLE4OV7sQ~W;K34{vYm<{i)fQ0$SP)PsW7hn)+lmZE|=vvo@s&eNJJWQ9qZ?s
zi&>tdc%ubp)7L)^pG{r+RFsqC(a0R<4zG~HAuj?ug<gg^uP4=JOc;Cdrs>Ch%LM1O
zNGcsiA`}Vda+=~#bFOIR0`6-qql2an71}6r7A?zCIwTUCz)z9!1N01RS(o~jUnKKi
z3q}g8m35a9{Aa-o&+-h{q$QIDyqelH&5e`s%gv(B?B(jasUt((lp;&9!sHmf$k!}S
zl`@pXs616h)`A{btk@xTHZt2b@%(|Ojc3~dXR0%VC@Ui9|E2gU|5391sgPDSTuJ@T
zBOCGtVOj`9uLc7xUaq5DM0J+M5P}wT3Sj49c5q}ks9F;X!9hvdh}6-?4P0$$p^!J6
r-v2X+wD2e&@1|TvD{Y>dN7gnOV;5I}Eq#Z%o?|jxY-GLBL1n)HCAA5y

literal 0
HcmV?d00001

diff --git a/technical-fundamentals/python/coding/problems/__pycache__/16_sum_lists_forward_order.cpython-314.pyc b/technical-fundamentals/python/coding/problems/__pycache__/16_sum_lists_forward_order.cpython-314.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..8a7381e6516b4e20e0cb0cfcaf017862807037cf
GIT binary patch
literal 1258
zcmaJ=OHUL*5U!pV%X?J_A}Anc&BnlhF-8-^87`=kC<g<bVYXLBXM5J}UJy=uFrJKO
z{{sI;Z)6e^6HnYA8?slcW_EogTFF#@Rn=YZxidC81V~?IFXGD<z;_b*<P?B)))2H|
z2LiSM>&&n@!q$ehZX0_JCSd^rdkO;Q9(o`$PT->KO+ivNZZNP2)zT>$sw^80rA$p|
z;#6uBOOKlb!z3bmpX>s#P6a_5w!yFfjI}dj?7$5y^o{Y7a>6i@gAo`;@G@sJt%=Qu
z;T!shs04JzI`atH@Emrm2k!uCsGEhSY>x#jumU@9d<$K;r&K`Z?uSWBWOgh~=1B3@
z9F_Z7zPL>>Zf_q`DPBEQjnHTcb~8KhpJ}1AkD7R2`%hH*N<>Ect1Bz7eRL(%ek=}_
zln85wz7f%$jH57Fs<&h<YzS$>MElJ{vzJOgN^7xv={Hrnn}`OwxX*Q~!IM}U%`xaf
zsA@b_HKCT9huH|{y`BorvrClV^6#oqOi$0`^>@K?r_YIfiq7cxTz!~}9W+DKYdc|}
zPM|#4xq+Y!TV+YwoVMm=zrPT`A{?{Ls-*_eriPJK?aa|4ssGYwa$KoY)EJ&wiSt;-
z26G+l<ywe&o+Egp4JVV=J`9~qT>UtxE|EtocU(BULJE((NbDPW8REQ=)>;W+?8Tc_
znDi{;oY!NeO%h8XQ_j^S#h>I{(*j03G)Bd{Eh9AAC~_Vx&r*3L5+l7P_8z(xwyZ;a
zD=w1xk98vj*2+4!5d3G|tiTB@-=>vQCA^xsG~3mqv7dWJo!KtbcQa23(^4`|vC355
zsC?;)RL9YSB6b-+T|w4{E;wxPoY=|m^qGz4H#}WD&phxZ&Ib_XMMS-S7GD*=O`bm$
z($0sgsNY3oOI;^S3!&*%f1p$USWdNom-3tj5VYaE1a1*@69<T6tGBQ$9Gjy3$UJk{
y#I;ur3Pt<r{a<s*N{@<Ruc=#Tr7q}MWM?*G?4k^8@hi-9J)7a0BkPXz>-+(yDio^#

literal 0
HcmV?d00001

diff --git a/technical-fundamentals/python/coding/problems/__pycache__/17_palindrome.cpython-314.pyc b/technical-fundamentals/python/coding/problems/__pycache__/17_palindrome.cpython-314.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..6ded46b8a8dc918c8803ae2fd61b214380c10f27
GIT binary patch
literal 1310
zcmbtUOHUL*5U!rr?($HG5*`vkNgx}A(S!s;j290=Vo)cD2eM3t*<Kl)?OA(z(dD#>
z#$ckxqd!6Z4aSSk#TZZAFpJ@8RnMZvt9_`hN6%MZS5?oYQ~f=F>(ltp=oJI_PR7Y{
za)otjsI*}NJhlu=OtA^ljb&rWROXVUtR-976HqZPfM?Dl3N7Uf0ov9ucy`6AIG4wA
zKgoGB*HyuDFkTpjct91s;uMri2NWu^tTzxMQGtpQk(SM@u-a<ywLoTtTU>A%g<0`V
zgMvYvvDGlg%Vigwb*9m7Lj@G`Kp7i7%Jgi{z=S3xjG3}LOW7X7v`%KNBvrl=68r8A
zz(O6tSZ7iLt-*$I?FB#;edBPCZ848|hG%+~YaoPuVBoRL-VWj>mj%)-!Jny}GbcpX
zXDG+|YGtOfM^|)eiL3`IrF<8&NACTU%hW|rw4J(lW%7uJDs``3x$@YJgyM2L;!kHK
z52`I!@o-B-VGz&OnxY!ixllozx{a3FN`xCG)kr*a8#399c^x4Z{6-K*qAHU*pKG+T
zKHu+_m-~J;NVMkucJ(5o^c;#d9D`wx{vh!_IHYZVW>K3R3`5v0Ht9h3N4wNHk4hUJ
z3<&b-^<Yw*R24j!f<3lUHe?^hWIqaQu$A(-_Q#VF@bvVw9Kby*`hFxLg<Si)Tys<N
zB$PIM9vXYy^ZD$^+mbv(h=vBv0f)%p5Q@N3Axe+$*OO{9CLL?>q#4BB$Z6lNMKV=b
zEiMw@m&25Q$oEs4#n2CwlF?>U@f2gHFs8F<ma;@933^f~(RvBT29~Ttb;}P@_<x2>
z(v>r73#VXb@b_SK=c<x9lB=c^nYEcDvF2B1@-)%WLzeR#L|c-e+Wu}cW2GN}Vt=H3
zNc)GXHZ^U{7!T`3NZ1|Lq5nf$w^LGuPtr}GuG4j!*B_;Sjh~#tuug32&%anjonob2
zqPEnU$RFDxssEXyS`D0JX`vzMyri7^aplz}uz%W+6|d*Ly&>rbKy1@F6o)2b>}L_!
m)K{4O2(#a;-rbweZ@1ZzW3tiRg?CrqEFJ->$9;Hv&FL35<s3@@

literal 0
HcmV?d00001

diff --git a/technical-fundamentals/python/coding/problems/__pycache__/18_intersection.cpython-314.pyc b/technical-fundamentals/python/coding/problems/__pycache__/18_intersection.cpython-314.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..29933b8bef200b893776a2e26823495fddb3e257
GIT binary patch
literal 1336
zcmZ`&OHUj}5U!rr?!tm01Q9R_Bt)Q93}YfoMpopD55bZ}k`^`xw2X$?-Z06~v+nLC
zSxzH4vV3r&9Q_ykZ=8cAG?&E6i5qA^TvIi(8<R-sLv=l7zWVCXpO24?0G_w=m+`s<
z@D~}w<CO~Qw^7Mp4>)@Wo6N8U(yfQqrfuv^$2gm=aTlOze*)aT!^*#mHw|bzGr--Z
z)AVl54PgQ9*n@8>+{1Wf29gO=<<%u<)J`eXVEJe$Wokkbr&2fUyt3Wvh$o@SD_;pI
zR2=2iuR9bBlbmfw@38>};H<xl-VB;x7zbnR)s4+vZec>35+=+z+%Ya^nAXdkt+XY!
zB4R(N036g2jP(}_peL|rZTt+-Lf<@m%MKW4+~PKOd<!AmQ|uq)?opU@g{qM5Nb!?7
zo*EL}U7;Mi+s&2cYbw!er|K{?n(}>`C;nqCl=jgRA8G#^m3}WGqy6>Uw}0?sX@ok8
z#gD5>gsq-$M06nIC`?w{UD*l`g*0KJ{Z7vuq|%SlRxH2sJ1X5z#34d#1O<RbKy2As
zr<d1*V9;O@1o<QpTf6QWLr(f8iVUv6a%ay;yb90gdb4t`F#8yWXwYubfjWS8t^YA9
z8SG3*@)l=jQ4aeG9G2iU+iF;<jxj~KaKw%lN&CG=6Y%o#vYNm<uLf8`Y>?~NfNN<M
zJP9R(lj*saBPSnz^lME`5u#N9mw?mc@CZd>vk+w@2oBR$Hz6H+@w6KzgUF2_Xva#M
zB$h&^L7-+R|8x*&+QujdjZyJ_*9eWVaf}t&3YMxyCJADsNj!%u3tQHwzLg(R_+M*A
z&kSp2{m)Rz;D6W5;tscbn^sMY;-|Tr#M-PMPyVxCgY{~bkuP#j3DZ@wVA){m2L4no
zTgi43ZAIb(3Y4$q3LI8DCvh@5e`e$TC*CgJXC8Pn=M~h7IwG3&@X%z75~!A}n6ILi
zmzgcKK>8vIO@9q%TED)OY6&9+5qdfqoL9juGi^0$G_H0RYr%0T+Kb#Xy$<fUa?nsN
z2})f&yK)Ky_n-0P)i2AL-&a&Dk=AP{&TPimWgXbkAF%p6tiE$bUp#pBC}S6%&1PTR
Q{cZi1dl!J}Ref0f-~PxT^#A|>

literal 0
HcmV?d00001

diff --git a/technical-fundamentals/python/coding/problems/__pycache__/19_loop_detection.cpython-314.pyc b/technical-fundamentals/python/coding/problems/__pycache__/19_loop_detection.cpython-314.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..efa61cbb048917bd570bf6fcb9687072b686fc8f
GIT binary patch
literal 1307
zcmbVMOK;Rj5U%!XX7YeUA%uj801=5skT{Vd@epv?13^LotN;fzX&Fxs@vhSz+CABw
zoJIm64uClF7dY}y*jw-gt@gw%Xh6AA)%L(@kMyBjkM>uezp9z@M@EML&;IPU_`L=2
zF9n0+6%OmS(CNVz1nefPGtK76w{BYNwzk(D?X0`nor8vb1_FDH6>n*85-@hAAaEN_
z!@DpufCX5y%R808!+K>3k}+Kks`F5<eWp^K<-?(rsSb6V%B*hZmCbHj+z(Y=xgn%b
zag<kYx2YH=IophWVgr=mtiOQS9yCC+0JOC=q3ys8ENo~~!-Q!kaI_mRZ0qIDM%ok`
z5wS17037rYjP*|&p!=|8U3v!4#M~_0W!o%Zffd++<68*fen$NucXz|2BUFWaM~c7n
z-o$|D!$s=xaI>-4ct@Y;wNkYc>WuoG&82@Y6DspD6YpmJ9hLqrBAxlGD=UBavD8BC
z#^TQ<CBkOc*CN`MaTF#?t&VJlJ3{I($^3R#Z>Q3a(q=3l`)!pzO2iIAT;@rdws}+F
zdnDR&yPJ=2UP>%D&&P?{@_$pukX3dPO%D#ia;LwLc^e+k<HO<=6ZWwTQ7Jh2KpJ3N
z>z_iW2M@+1WzBhTS`L(j0OsKx+o)S=1Z!#(4G!7KMAG`1$q0C1VL^@IGp}+U%UC1V
z(UNNs8lHsGgZ;^wmqYu<PQ0$E2|~0CZ~-_;36D@D%7rLHobRN~PC`Cv@uU+bW#uU6
ztypC`iKUP!=W2@jPja5oK1Mv$TE&k#T4Y!|f;H34uv9e)$q<2zXg!BR3nlB5ZpB3^
z|I(saX3-oqi~zZ_jhnDH{$shy-D>2X61t<LVOD4AC=oF$RxljLSdp2g!YmpZFk`hZ
zWIh~UJTT7-*Gy~}8?t!O9D>5Zus;1g^vom`i96^whra1o&TY8ZI<tZ5EEY{)*S!4E
zshS2G^%~8i)j{Go4@HB|J>6~N8Y>3_MfVkTG{3AuW&-=4{(1FkG1Tko99D^Iwv6V$
tW{iEC0XF{$mi~sNf1KeLzdgOxV_!X+O~1JKX7$yTuYm612#R1heFxYd8#n*}

literal 0
HcmV?d00001

diff --git a/technical-fundamentals/python/coding/problems/__pycache__/21_three_stacks.cpython-314.pyc b/technical-fundamentals/python/coding/problems/__pycache__/21_three_stacks.cpython-314.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..388920f902ea9b2c7d4c3ac668483e48afd41c07
GIT binary patch
literal 1935
zcmcIk&u<$=6rR~%w&S=-p=l}<Xw#rnZb`R4BE+FWNE}F|D!?X0NL4bLt|#@9_3n0N
zoXR&#Ai<Ff5*%~r!8iT{{s&IX4WS--D>5`a^4_eY*w8iziIx2M&9^ge-}~NsbLCWH
zioo-D;m_nJO2}`xIC_GSF^s_IlN}P#+hmPuy5?wS&DHLjr@ixJn=X>bS%uU1Xn&5t
z+MOqnx9x2E@4Qj+h^uaC>mc%%NHchX%cf^4o4rD8acL?aiA=~OHr0;{o#Yu$jdv$e
z+R)9oJX)eNS`6D@aENW2Xc`gi?9{Y-mgHoM+@ukmCuucu0B5yl8HfrP&oaJce9Huu
z2`p2wOw}@#sHUr1MAxDzh_`O)n{6q?hUW2}iZS6)(gXv-<c1djZqYsju;aY<6(KEP
z7s#iy4dHCiyCkIG$a#YM%`}&i_gE^j`?}qv#!WKabWE_D%MRD3!C0JfrCLd>8B=)V
zV&A0UXG%yF!j5ELg`dd$3lVD-UcYv2F9Zid?kD2miWI!n3$=*bSrYSfWw)EPct>QK
zrz$LZx}9fXoVSwfeptx-UMe~&ym6gr%#SIX;MJmMrWxZ|mTRsBW9Hmg`d7!_U=OJ?
z0MGm6kWjzzJHo++{Tl*L;-iw`0#yTDszdCsK8eT@8PN3s2xB}Y(p@<XyiIs{S<ZrO
zs*ELB0y3C0lQEPmet+m&XTMaZ<?CQgln1|K%X1lwSCuDnphz@wBQJEJP`<3g0aLSr
zu&moL{ytB;!UR(2uFTe(j%>gVSpfk16xuTYqiWgU<!NMJ1Hi57BEW=9Kg3T_t-+%G
z`_Z$al{sL{N6!mHlXLJ=o&{*Savtpkgf{^c9$h|?&nvpBZDz-%L&k=V^Z8H3P)w`X
zyI`EG7^voqPkQJ;NnNX68Pi+f1_=8_^!+at!{V#+0F#PsSg8&^AMi(a$K*Pp$ByM1
zILC5L^qE`ag_)VqDK9Vx`M=2|m(cy&04FyPHuekTC>!XYJ$UeF@4v_)m(ee(cib>S
z?ES4_fWhw{D`7ity*Y)`nZe}((>cXhCvSCAwBhb}(B<jq%?x9^iBvjGGLhws$#dxI
z0>UMPD*$E=?m4(?l9+L=Wpb~pg#u5f$8N${q$y)fT8<eG#Ruh-)zAw9{?rP<^RMA@
zIdovQY`Yu=FR`BC_}LM#=hvGR6X;$6cca7+kRF0<TD(VW=h}@n|MFaUN!==Qe_yV`
uJ`7Evuuok|>0y=7)t|}DU%mP_AAWhKPyYz&wDIkw?-#$j{EUEU{rm;_P=+)B

literal 0
HcmV?d00001

diff --git a/technical-fundamentals/python/coding/problems/__pycache__/22_stack_min.cpython-314.pyc b/technical-fundamentals/python/coding/problems/__pycache__/22_stack_min.cpython-314.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..9eecae1bcb1d6300d3f9f479fc785bd8f72c66ed
GIT binary patch
literal 1616
zcmcIkzi$*r6rS1LTQBw<zl1RfmWVMjoQS>VN09<Wky6Bw$dN2yA%Q(w_QvtR-t00n
zXLPAfB2s7~B}EFlwEQ_KnJ%J0bie_o%zLwU_7M<NZ1LTjw>vZ6``-8N^xnoKf#=EW
zD`6=ik8v@2!eKCILC`1bB%$Av6>8{;XS@~P_{Yc^og;~N9(Lkmf@uP4e}*K%nzt5w
z`FWK`JnvVrsU@{}(hQ&CvgzB2E4`Ahrpiuy$0b)Hv(cr}h(e~hrB||QQ-$7eF}MLi
z3XIl>p$ReG`jqhxlLGk70Ebm_jwap=$s=Tv?>9A<30$V;GNH?aE;HdW6G>#ERbuue
zdw|`fjV_xsyZwWZ*|0WuH^xv$G(c(kBq8(UA#FVbuz}|JhQ<#Ttcb5_u5{c<jo8xh
zkE*!EGo#}(%geW8Aq`hsg5O<KJZ<-4!?R5(vNT`Z=*o85;nJkJj?13eEM%M&Z6SY-
zOI6&=c}K@*&oYh7SVzdEvS%a4gcOD`dtk(PX_Tr1nL*7leH7IP5D-_*sG<N8*p<Nv
zfD5!wR>`{e)vtuKAv;TcqMJ0Km+5uraN@@v=n_1|9@yGens>Pk6*pZaTTQA^kEUnC
zjY2`uw!v7Ir&_l~2GlfeI^I`%ac`ZmRLa7nh6Cy8G19x~eej_^3h<^+wh65@o+CV%
zdxk%M2X3Vf!uxDw35dyinxoL%Y6_s~sRqW=0FKYXLd7R2yL!_$c6i_t?^g#9+$DJM
zNHf&SX|@c(hcpA-=(zu53SRNlAw2ak0L0jup>k>l<0Am$VyVwCi$jDw2Kf3dMgF|@
zApPt5m>eUP@ZpE$Q0R@yt(6RZS(LWEt3pxYm7hWcbqo*w0swmQk+QK{Y7Swi5wLI%
zmI{p+AI05nzgr%R%UF4^a!2p<*m<OdbI+KB83b!iGS(^D-5g^u?VWC#58v!#Y(pq*
zav`}a7*ozKvp`7ABb)@V)8KnBxyV>*j1o7yhHISCvB}7Io-+p1<NA&TedC&;B0L2F
zovTj)y!j3OZeDm`|LqXK4Z{DT*Ek$bC%3iL3~gw7CH#9RG_1mD-?dzI2cBPTakCj+
zs4D(ip}UcgUI2LJQ%bk%gf9I<7XJ;V?tgplVxPVYr)cB;-9PU9{>y6up*!b4k0nDi

literal 0
HcmV?d00001

diff --git a/technical-fundamentals/python/coding/problems/__pycache__/23_stack_of_plates.cpython-314.pyc b/technical-fundamentals/python/coding/problems/__pycache__/23_stack_of_plates.cpython-314.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..304a78991bd04fe055d2253bdd50f36a090ed24c
GIT binary patch
literal 1566
zcma)6OK%iM5U!q?9S@HM8?c=aD*=owt-v1hIB-BHj{{B=Eiix;3E8b?wigeKXNK-x
zqrI&}q;O0QNa2<o`8heJZ&6Mt7otrt$5i$1!Y&{}A8M;>s;aBL`f5)dsP6?le=Yo*
zedz=INte+Hhf2SRN)I+6VPC@<Gi=Q>-kNXx&tQWchr~P22A(FE1-$$7kOUjvMsWJ*
zC>6kY%udJDlG-9P!e?}8_;%_>x035Z*{RF2kSa@Ubfq#`S%}=S8!35>jyF{L>!=8<
zXafvOz<8U}#-D={*5MpW*gWJ>;-Q>2fwN#eXbGI9<}5X537sWOrp(kjm?(*`u06JX
z-H7zwmG;$K7^zcgZP*@A0n|qS7>bLmhYxOg7rqB*p>+YSu`PW5I=cli!&Kfg^0!ec
zDv@TU+hEqu3e)gx*e=z!Ft*NlnhUL4S!y`f<bI-O%lM|2O2_Dt?dbTbD(}kF==jX)
z>b)2fNVSv62g^!|RyQ^>-72zF<jd_&(GuITFe2A+)iqmX5vOG<EAGUVDsSg<TgPY5
zaZTOvvdt^k-%8cB`#BdyQ5x)*b9;26|CRA?GgzQLg5qTlc7fIEf0Ow2u>0ww9n#T^
z=t8g|Fj1d~)Pn>T;VElAMPzKCW!_f%(C)fkT2cp5w-M)Aks%g#?#(I&cB-IXbLoDM
z_NzmvO-v|2gPYJvRNgnC#7q3x!zl%d7QohaMBb4$RMK=*(QGh9MK?TE#~*b7#c({X
zP&G|fDu&R|pP-n4<jL{pgv>92LuOFs{~)6%lbS_=kIs=!Strm5s*c{WhbECBn+yGz
zV%`FTz;J-9qVhgKkhW}mUk4O+;HU+R#i|JR4}@hNUG+yOCSdvLyC>rDtuahSi-nHw
zV#^pN%weJ_V8|7}Dl0ql1{h^UFRNErI6#}Y)yS*@w*#5Am-Fqi)yYXm=HKs#eE8)c
z=j}{slV^o2O3szb^(iGhfx^z>j^dJJDHq15>~;tLA27+x*cPWU&pAi-IL1)5pAQHV
zQ5F)!9KDF*<qx<MyB^ZSab-80&|VOK+&EoSvk}_RbSvCuMdMUN^w$G%KCah6$Y7Z+
z4*I;LPN6f^qL)xS_ZefmbHG-9gXKSheUH9+_-&8<6Gp85<K>^fc>K)^K-J~>4}=Xz
Ap#T5?

literal 0
HcmV?d00001

diff --git a/technical-fundamentals/python/coding/problems/__pycache__/24_queue_via_stacks.cpython-314.pyc b/technical-fundamentals/python/coding/problems/__pycache__/24_queue_via_stacks.cpython-314.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c2168023d66dbd2da54cab67c6288ceb0650c711
GIT binary patch
literal 1929
zcmcIk&2Jk;6rWkI*PFynQfQh&BlS~}tdeXfK5(ciBn|`#3|UGpC>c%GlV+Or?q+5j
z<eQ~dq8B83;LrmS94qn9aAa<XQx8Z5L(?PgjlFUTZF*@}^7EVD%)EK;_dc%9Hl_)D
ze=PkYf2M@|j*IdO#>%h_%7AQ>n0`#wsiEth@zyJ*a-M9_izN11a1%e{FA!K)7D?=H
zd0YNFZ;x=4t;$F@)wp_@G=oRDY*uXTX1@@dT-n-3A`?m`HvFtGGS7Hw>CI$xX(YYz
zVwi!#!J{o=XiSW^J!L9qNDlrjf)AVIJsNw9Bn{D%bly}Q;ya}3kia2<LuwAGIV5z*
zltaRJ+DvT{Gab)>zja&tw7=04J&}xqb<Us;frUflYCvLgnLMQJhajx4MY^l;z_Kl(
zFSSrQ>T)9wb@aK)Z;Qm}=-suo{YYj;s6#2fUQvQ~`jHXIUM3TsuI%=*4)2Q0@Ki@d
z-|XdCl;j<m-HHm8@1&xuqiZd8fNrrv$(c4h+1IN@--e9IOd7`Q{Mhf+62XKItIpqF
z!}<^u;$kY}@&UkP4X=Q>P6uR@Y<utDC8PuB64{`8G^StBuORVpCGvnA{}HCfRu6gF
z6E;x7^i<YvQiZHEJsa%i3PQIH#*&n4-H{1+rt#9Hfttm;b;fv><%SypKA)cWJV6_9
zPM-tubU=;>tv3Ed@nGXI{{7f;EA<BKCuO04PM(t?g$$?}5KT{^RkZ-ZxwE`Ha;GLT
z$EuwxJsAV;_$j>OUP9|7Z^)VBZ4H!@cmwX}@z#haRE?)jqt!DYK*#iq*;9+Cp9OK8
zF!dIq*kALwgWJ#2a`vZ-Kb$+pN$DjVJed<!M}v60<f0?~!^IfDm(^?FLY+s$7eGLM
zUK0JAaO(fj-`{(1@csTPiQX@S*thkv3~+^Sz94R_JXZr3Ksl)fFy}7LCQOQ*JWpR9
zDwc-EB6&8^S6)e&q0~%t3)7#>ixR<iC*iujX*XwZ!elU<pj)RI>*k$aiaPZ1L64{7
zojJyKrP3yqnaFa+)EwGcLU9SjGK#Ap>;lXKXnvV6Zj6#UJtH)jJ9TVgBqB{2gQ?<r
z0Soj4*Q_c;D=4Pmr>}u{`V9=@zdV==M*#>oAzr9G!TI6Z*%@g!0~?rr0aI3CDizMd
zNkfia!{ITy;-*)4eMG<w)q)LlO=D<}E0ofskkHj%$jWd2%)Jlqd@`Va2eY(s@78zx
L+uKhFsLsy6fl7Q*

literal 0
HcmV?d00001

diff --git a/technical-fundamentals/python/coding/problems/__pycache__/25_sort_stack.cpython-314.pyc b/technical-fundamentals/python/coding/problems/__pycache__/25_sort_stack.cpython-314.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..fd8beb2454e4456d791b082b0f0c94cd21d5e435
GIT binary patch
literal 1923
zcmcIkOK;mo5S}F|ik2ni(b{fW19`%LklJ(-7sw$f3gl1+DAblti~@nZps97mm?D|o
zl>_A@paI%rdoWPna?Q`lvAh*I<>ppxoMUHJQY-_Bb4hs^&d%=6e)G-aYQ0tg{0`>-
zjUQV8FK99T+>tV9qSA*=2-qE1Wty#8+FG@>eI7R0MF^}FHaw}F8NjtY2Z6I;Z8)EQ
zI(7xHVvo+0g3@JZxG!nhu#58DUM|){S(LvPsgQA0c;Dta&eAX`*xl&J0RZAN-yp?b
zh=?{ovjDWUS=II|WQcDLw6hL3SYXXT;t`VMv@RKoV=N_OagD__ma?&wjm0yTDP!@1
zik?~rT?wWUZ?%|O%cNe@VYCyC!Zlz>$I!e1vDJqFF2gg{e1@WMlt{J}9atzH`1h2M
z%I}0a-c|m0GJ7B*t^8}t%R7FYY9V)H@n}(su+{Umh}vl!g~{S}H*JL-k?Jr}e%{mV
zEcK(T6{kP?xy-f_(NX^OFStTzToJaVyjOUf$7!rNFV4Qfyfn7e5YC`vu>Rpy2dIFF
zXB?A*21?c73W{5-59_dL-FyPjLhC$y&)O_tYwSLzJ+OTXsc~LXVv5pkm~=(qN};<l
zZ8n%BMjBS(Zf6q1E^3@dNvKpSju4xoOPBhxPIs%EhiRJWPzyvoJBj+pei~1z&rrPX
z!y&Lz?JpAh7Z2$7)G;f07WboZp`Z?L$&aLxm(wU3mLxvp3<?8iVPOc!$-Amu)Q^DB
zngGZ%B+M)1dCVFyW>{NB<s{aSIX2lAKEryk<j3T776s~*oDp|&j`UAZOwuLKk(GMu
zBif<uW0d^%!+yATe}a!ON<4TnAF@gg>G+5TJJ0f>HbFy{)0_VX3-UZUzJLO=@}9Vf
zskg-4-ha5a^FiWvav^q(<saAd>N_H*iZl7YfXYevr+k}88#o`fvMhOju#{~@1#&FO
z`&T|lpkA!F=;XRLIV;9CQ)h1q-gHc}F-`L&#i4|qTH(BtwYmxE*uxLIVKUk|#rbwD
zl}_SRq#5V(6b2yYNn9eaK;kNjVg_dcHhvuOP-_`)b+u6F?##rrh(wZbjuXXn0+r`i
zrcI?sUPzd_y^hN3pK%EPZQ(>XbWxbu@J{U&O%Bt{#!0i`7Ow8)I9(+rQ_?IvYRBPg
zG&Y7;%;fTJ4GH*CuHXhiQxw{P%@{kZ16z6yi+?)Pzuf-mn?C!;t+U#%<=@#}<rSc6
G{QL)o)_E=f

literal 0
HcmV?d00001

diff --git a/technical-fundamentals/python/coding/problems/__pycache__/26_animal_shelter.cpython-314.pyc b/technical-fundamentals/python/coding/problems/__pycache__/26_animal_shelter.cpython-314.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..6e64350852e7dce58ce1e02686a649f6b5e4fcfe
GIT binary patch
literal 2449
zcmcIm&u<$=6rNez>y495QkoyMq$Ev$fT8K8Edm4;Dz}1=+isyCL9^PfH_gIk*PR^~
z<>mttH^h}=j=u5FRDwMraq6vLihDugdvER3Ms*Mp9VyRm-@JMA-uJ$l$?LOrO<?@7
z@;LgdB*d@uF&yQA(z_0&BesMqKM+@?mRAjJtcu&xt)4qRbQVIF7R5>78q2~hy<rq~
zU1nPuw#tF6;+m&K-FiqabtA8S6zNd;ac*5}=_pP7ICvUVh(RRLy9ld~JZ=juU7?Mw
zIbB*3skkLBNmnk5*rL7Td0lo(x^hcs(=B74N^ZWNM7xM85rF<^P*l__dTS7uWd~8V
zjJLlLq6zDYxFL5C^QQb<I1(|8hvc76`y9yAd#$i5^I8%2V|<|ub30YLzRqpW3t~UZ
zno*!VFQbL)ojh?q$wHMm@QChb&UKZ383sCYE^Kao<wOYpxF3aIZ>Z33?m0RPc9JOY
z<Bjch()4%3MEh~(wD$B)nm9q)jFP)fOQm<>a5r-<zUd9}%67sSk<PdF@)-}tB-OqS
zJug36WO{zoIFH1#1&Ajd(HF9^_8W=)5BaADy9kER)5icXtM>vvI^xs$gsePVaY}S$
z1BjFv86z)eVZ5!TFw6CyJ*#G+=a%P1Nd#2#xr2lX11D33Pe=T;u=?GUIs#o$c8z+K
z)+Imz>uR32n>O1q=_v7D+m8n`bDp;ysZ7UF5+<qVsTXO-MRWidM1kjPt)e?^9cEa1
zWTZzy7{{L1mCD9~jQDYdvsETk7IQQ~;>owjuWtaRKMAWMNpgEOVF@80D-H;|P!N{L
zs>@7UBCO?>n6{uSh>W8GONA{aTTHf8*-~YT#g-|ySZ+;Ef$TMR8bqDR?E=}G1r?a{
zNP`E}26kILO1UGbZR#l0F1n|dp>Xv@uL}5<#)5%9MYk5=+pBPppRE~&VeD{~F~x`L
zG?c>*mut8s$3Wg?Wx<shlbb5kZIv_>-Ar{u&Cm=tr#MSRcc>rv@qgy`l=Ia7>?Mc+
zy=~&Pz5mW5`uXuRe-)XJvV0OmiYie{6qDSCgsz6ky>{3R^TqK*24>1Zy+VTMJO&ZL
z!w_vkISeA)L2~q#rTeIB6mZqC7COPrL_HKN^%~p=klrzfF;sr|Y=8T~iH#9VhSwxK
z`O172Z3;}zz+;3r`E)a6NO1k^<;TWh8JVI)o(D9_p}+*{zk~5Ixn3Y~&>np7IGhI)
zYi_1@C)JE8-tRfk;lI>;66O8BH3xX}CiEFoyx&31OqoV~TG77^iaD@C+6fYTTF#Mn
ziNsqZ-X+1ft&+9|F?vO>laU0y6dC=4z*qF|xT5X83Bjj*qDHs4&CTZ^4ZPwdYGDb9
z*Uj9-YlfFr(K#&+*)(bVF7VELDey~GJa3nax9L4~1%5=K>{W<IB`IZpLC7<|*bCo(
Y@xWg1)cU3&@!&%AYqQes2?$Q)Z~UCy6#xJL

literal 0
HcmV?d00001

diff --git a/technical-fundamentals/python/coding/problems/__pycache__/30_trees.cpython-314.pyc b/technical-fundamentals/python/coding/problems/__pycache__/30_trees.cpython-314.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..3da965ab80da1023cfd039df666ad540c0ed8957
GIT binary patch
literal 1958
zcmb7E-%lGy5T5n@vQ03i4Unc#NN6E$fg^2H+N!E5@lYaFZhE5O0h!ZrUWaRsJ7;fA
z1W#65MLZ-`-ugH2_w*&&m!|4d-i!?8wKI1<1W_BcE8X0;yR$R1GxO~SmEkhr_;vC$
zSk(ajq)9%^46y!>2)eKZ4!a9$OtNXhg}a3{O=@ep)YlAYteMiBhK6<n9PJLvPD*PG
zaIQ~)V>I-JwQxN*4R8m&(U8Sd$3z|LUv)}OaTaQ&mvo@U)Q}fNvGimRM@dar*7|;%
z-}i*FzTy!Vfv<|+v}w}|RdLk|LvK6eimm%}JRbx1tUre<U1)%04#>h*NotPa6fhiZ
z0>Wy@r0(d_a2N()s^YrfydF1s-KRSa?g>T2Xpr@9rN-{VR^gMM0h+ir3E#3E<}jz=
zXpWAib;opcTSs%&%L1w^W6ujaT#yZ=hrA^ZCi3t%=W~CX>y7z_GDPrTM=G=J2_DHK
z%7xjA#jYn43gxEa_IC*viH$44USi)9@%P-9iG6!{`3F0QBo})Df3zsL*W9-y_jjVe
z_rk?iCu(}TXwnN4yS*=W;>h;nW)MBF+akv7?I!j|%dW)BCrj;pb;WfDCE%{B#_}MS
zE-q7FB_E>b!Woo}sbdl^Myfpn|2-2%=6V*PB2?#lB|>Ewy>&c<sE?<>H%JZ!B?^;S
z>VJ%&3mera-+_&pC@%wSEJvi7j*Ty)L5%?%n1v%&ujyhK_e6!n2#G3+nxXWBhpm6w
zODKpr8sbevs_42w6iB@E=!HvXOX-ELp;i}q6&Qc}N%{HJYfnng$F3t9pZsM=jFUG#
zb5EYL7$~HgR<GBozg#!MLZJP!>+Z(QPDmKj{jlSOgPjrAZ3QBcVG!{sc3nZNQe&>0
z5G8!qlTrlR9mx~i8znd7H;rFVjHxIgNUorG3}=Nj<tQ>m((&;-AA^*#{t_--pvnYN
zg&|RpEMXOCf`lQiBQ_jEnvO|5u5?P&CAQGJf~8^ocT;<>Ws7NRSUO8ks7jBJc?V<X
z?8r-i<Unrh1xX+ergFk>ZeHA8n5oARZzxl6*%6V_X_{uI#>5+FJR?w+rK{vDE%2p|
zrrHh|eg=jyd`#j+WwvMFA3M6b*s}-~p<FpGAxiV<pLZc1r%uIrsZTlRrhO^MY#Pat
zCf*|a9tnDu5;}U`d)js@$sV93L}@S<?swt145fiDvY)fzf2UbcJzkd+QA34kQhJ{R
zwbg&WomfEiS8miizY(I;u$>!D<EYmxF-a>^B;FyBYAq6?w?)j5c%{j2(i({g{1V!H
z45tOG$5{nMTD7dxNvB>b6W3ZDYzyR?pp+|9?zi#r6FN==JpqD}DJb3PJDu?;^>f*`
zDt?}^_6tET6_q0S6h%*CjGdamW`Bp3-(ckreduuYr?0#0#2jK%hmW2;e0p#K2u~)5
S+3?}Yv)fNU`wI}Jf&L8%IFM-o

literal 0
HcmV?d00001

diff --git a/technical-fundamentals/python/coding/problems/__pycache__/31_has_route_between_nodes.cpython-314.pyc b/technical-fundamentals/python/coding/problems/__pycache__/31_has_route_between_nodes.cpython-314.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..23df93827eaa1ccebc49fd1563d565b9aae49b6d
GIT binary patch
literal 1307
zcmaJ=&1w`u5U!q?U3X)Q@h3(k8a2AIh?xXEBp?c2G$4x(njFM5v$MVK=%i=u?oEiN
zJ&1UaoIQFpHy^=A2%dC6Jb3b!u!IFqR`n#&2-?uqRn^s1^;K109y&AtxPFdp$KM#h
zcM^7&mouz)1DP%?Lcr$W4l`_=cxTSJ;~IAyM&KL-?kEJ_H79>zyr6(`aTJnaQwR=B
zK(+LPuBt3M7)qI%(8Q_KD0+8eZKC{HPTl-qy$Uj2cnpRGV4TIWaf3qOpkIuY3?~eu
zc<7y>_hMGQt-^MzmNrB!LL5Mw7GXe-talcfF3iKCGxHLlfx0oc&sr>CffKla=R4@9
z@PiO!h2=2mh|G<p$;wj1Pg?a<=@&;R*GHH3B3*jCPKb)lR4s)@Q^@n#ivLgxrG3=I
z%i6!E(x)Oa+Mk}9dgh};p_XH@az%--vFaNUwPYNH$(3eDHo_$#O_*rEy=q#i^rN&9
z%O`$YrS(KCY5(dpZ-ttxv||LX3$r4G<Pst4$@XeC$oWob1?Sm`y(}mH)KjzdxGhB=
zoWcUzvh;1VY0r(xo4KNgCJ^nkf_R|9pj__FAk&3~VM$uM<{eR{axR>eyJd#}CSVfF
zy<fA=YE?&}F{pz`s&3|Kku-m6G=;2GDryMNti*XNV}o#x{s|}7StuvbtP7t<PQ4lU
zJbUZYZ0-Hr+R(;>`PbgskUByk92+T*aEug1ax1ac=yrhfrL@sWh{yUp?}W+D&0)@)
zvC<}qrI0D-YJ?IR;at<~Mm#h|#dU0i#=Akhv(aqYsz@Rc0;&ngE9g5^?Vhc2Zb}CG
zMwJu@pY<*v^Pf?50{mXSOJlD}Xqpu;CuMBJ%oVbc6_qd@B{Q#{risn2%G4n=&1W>v
z@-WJZ2yJ~1Nf-LSSb2-cyV*@TKIF&8<5p=Ck9IyeKFGhB&6$$#+O8|Aavs!Cr-?s<
zMANI?zK;H5jMaHGvgs6%>B1MUWJA`lY1pb}2T@_G6b(sMG^=g=9?C-@FFC#bs~1`6
mdfwn0>LT9Kcxp;#(`Afp4*;9^3Zwm^%jhQ%?GGYq8}t`O(jhhg

literal 0
HcmV?d00001

diff --git a/technical-fundamentals/python/coding/problems/__pycache__/32_minimal_tree.cpython-314.pyc b/technical-fundamentals/python/coding/problems/__pycache__/32_minimal_tree.cpython-314.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..aa4e0737632421ec155369a3608992bd3114a8d6
GIT binary patch
literal 1415
zcmZ`&&2JM&6o0c{UK>LUjR_@@2m~cHlx#{k^iWlmdZ>|*+pYpRAZN6!$7Jbx*UXF)
zIj5CcRUBy5WB&#In@YXVy|h(N+#DH{Th;g0UKEh}4sU-m@9q1&ueo{dYz<KUU3n92
zn*jgNp%iBZ*z^g44EDfhccINRyF%EwYqU*mwk>V7ZEd$5?OcJbc@=!~4x9a{D^0+&
zwFJK1wYrs$FPEVK?jRe9c6|r!l_iK9y6U@Y(5k*7LyP5Sf+R_GprbTVEi13=jECYu
zAoI#sA`vnQbNA~Z8G|^t?nO%HY$v2&OPN!!={nwI&;`wW(8k`PHhtSSkk%yHm}$$m
zwCyt_cXD?}3eib>q7zab^ICwqfdSd{dJ*ga>=~c_0MNs`75J9zGoSf}Z~7L7wmg$U
zy)w`>w-17NB&18&ibY=^EtP3M+$gyo?sPZ0xh<o|`}zgd?(|bR2(%*lYkBP5S3)We
zZ=wU`eIwH+BGk(JWNYg?FG{qK2a!0uB}LF1ds>A1NfZY0t^O$K1p|@jAXeURtoPHz
z3)5bdJobh%eH4p<^0sgDL6k&;Am$ni-yDwfI_LAw3(oUqnd9c^>n7%<K0=kj3Apz1
zF{!^68WS7869*R7Clx|2G&YW_h^FWZp+$Nw)E(?zb$SCq2D^=<w7~9aQuZBow-WL!
z#D_I_!8$Edp2f2~M`{5TZil5r+<)&{5#2h9ynrBgImb#h)^z?<O|z?_o)6F~gGn7O
zE<dlmT)gzW`m%ZX=b9uVa=xW2Xj(?6L+iqMf<4BdHO>cVZxj>87Cs#X@!Yb&c|Vd$
z$5A4ZlymtZrPJhG(RPPC&{{^1Mp`JeHPBWt7D-EbpM_dPpz5f8gcGA^D5{ww`Mk5N
zRClqgs|Ygq|7G<ITvS_9*u1V%sYQ<mQU>Fr3cV;?%iNJdk7RPxe7m(}^U&HY(rqz$
z9wW?_b(S`@Qj%IF!!jyb6vnE@q<%e|(C4?CUlhlpilPAYD}<(B6hO}|1Dd;BLRivW
zMO@I$M_WI=!}2;>SINUhmBAmDTQGE5H5yWXg!SN%BoaXG=<yIAgtYJ=$zKwstdOEN
zI~xE+d~Y(j``K*VpUVxjQpRc%)x>0sy;%Xa_9txr4%>fQXP$le{k@F6cB*Xo+2Jow
Qe>!>%2v06y3yQ@40}~fG=>Px#

literal 0
HcmV?d00001

diff --git a/technical-fundamentals/python/coding/problems/__pycache__/33_list_of_depths.cpython-314.pyc b/technical-fundamentals/python/coding/problems/__pycache__/33_list_of_depths.cpython-314.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..bdf8566e5e89e7b82e0f99cc01b383f42c7e994b
GIT binary patch
literal 1985
zcmb7E&2Jk;6o0c{{z?<4V3O1=Elriw&}M_u0|%4~NTgC_U=^A}<gB*qakH@5b!W#Z
z$;lE3^-v;?{0sSSDsd@$0mP{{M^2S1@6CGMBvmRg(!PE3-kbONoB3q&QW<cuYp;X4
z4)8B+@?~WV8y+Cjhb?f}eOP0XT_;|<udV4)Uo)h!W=eC-lGb%-=^ufk-(%THS*QW-
zjTvyvmeDHQxstmExQEeb$)d8c(57&qP01;uzBB`2RhFIdJTxk==x~Fj6)%cn>B%6D
zl7^8M*7v&np(oP9S3Ke(@YCYgT~c~sYCH%MnX+}Cj^=BW1{*G*qz^5S%mJxwRiy5i
zj)q}%3L7$MIEFMGhQY10xGp$v#%<p8sn$`wKpjJeY<NpKdk9<FXFmh9QFax+W!ubQ
zj^^l&fvyc(Cs(gDG)>K2FYIwqB;E*lNAAz$X>Ts(u{PIRi>=fY!Q*XtNVQv?SnPN*
zq3}1;$o?+jBC$~t>?Za%BL1HHGO<5hUjD%jBFV*Wz@Od~+-vXIlKb0H;CtcSPA_VE
zJ3NwJnAqJtxgAHgAGd?(vE3E%qmb_;_R5MIV(;9z<F<KMZYN9Ky>!BLN4@8+o7VCy
zmrjc(Ftg+~l0KY3(X1a4`FpB5F!4XIU}|AdAg&12#iJ5(L$n3oAUayqAM9Ug_%Skl
z*r-Oi1~zU)dFNqcIU-B79GHhg)@<nF67Iz$ktrmI4<q4W=bSj9a0|G^Wn|K#>jqIE
zv8L%$HDw}I&wFUqhrtAVP=8*2`Tp$l(#zVFgR-bm2>nes6{evzn}-M(*Nw2t=(Oy*
zJ8`=g5|1r>((}TRX3BLtfk<Q+L_CUJSIkj5HP=lD-@fZfDS}5m$rIF7QKurRqy^n#
zMJmW7l;$sRqN#==$qdQH$8Wr_t+d|4{>;0vPuJ*e>{AobAsgO6rVkfm-_{WKrl1_N
zL1d_p_>X5$pGQ%sSLHUCn8rgH+_SQ26lpCtJp;X2GOZ&a=xOHM5s}}$0sUSquBxr-
zi$7`ungWc`_Mtj?5!wi0Vg^kbT2{j?;&nkm-v|=&oZ~8+=JcstGf1gCsTqAh7%4y<
zlrk)7g4|~QD43vf&QJa($%v4}c=A}}kSfh4PwF!dm4Sl)JFL_YaV+<1<A*7~9XO#@
zY6&iTBHC94Zst{z>Rq!FG{9?=_*En{DaJ}iL|)7-4b*?-OSR8NHNNg>O}wgsUfn*7
zN0P^DpjcsLbgw7FGf$YfgL)O(ROkORiYi94QK389>0vo|M+MC=wd7tGUqnHD6J#$a
zs3;I2_-6M{je^{sn^9W)JiGF%!bUA6o~$An=!~(~WnlAv!O9=7@{dt@_Qg*R`s~;$
dvHG*8zdiYN{}_-xp4Hi0zDM?C0z0I#{SU7KmtFt>

literal 0
HcmV?d00001

diff --git a/technical-fundamentals/python/coding/problems/__pycache__/34_check_balanced.cpython-314.pyc b/technical-fundamentals/python/coding/problems/__pycache__/34_check_balanced.cpython-314.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..e2b2df71f9bcc434c8a8eed8e9a394e3f4a6575d
GIT binary patch
literal 1393
zcmZ`&&2Jk;6o0c{UMFtiLfwQ0)Ih2P1IY%F0|&%~1F3`ztU`0BoY7`Iu9t3R-Pv&}
z=d=<C^-vK11E=2jQ{Yzi0*F&@j@&9&-Wz-Ahr}G-{@%Q|@Atmu{iRC_fX8|3S@Meo
z@DC}~@n(Qc`v?j+f{@*WeWuxU!q!b|-`4iNqn&+MyVs#>zYU?i$7X+NuLY<(D-gO}
zr|W%itqKdUXU~0Vp@;U`3ZzZ#hyDh%>rcqkX60feWu_yYWHN8tW$j=*6t^N();<?f
zs3b1^FNb7|(vls-&tn73gR|)--WJdW%|g)DQA69I8(K(c6Jg4<6FS-r8Pa;Cf1rfu
zWIfS|se*YGKs~^KY<j~4y9Gzq$KM0=@a|3cnhjXULMyaG2SYo7O`)D(AE9(lqjV%x
zjj)r7zCK&26284vaos-XZgopnC3gn;5moK=Gj$T_oao;vW$;ZdR36|>a+(KUsq9-3
z>pb{yclU0PNG;T9BJOW15%tD_7V$tPag=WNN3s{42&tnq4~Ans$Yc;_y+qy#hAKNw
z#YrA~w8!Iti0|^_D2-$+dOO2$+2DNMb-{Vrs<Pa9@%j>GmcNUlfD7>5wQ~}GEjK4F
zekUF*Z%%52d}wZ+*AY$87h;Fx{7`?efA#5m2nslC%E|(V>$2)R9PUc;G$(`&c*Htw
zTQyKul!RJB(RNBF7is^M>zwE|@u<rPN}uyYCK_wH{6bB$D^t(w=vBa^0aw=^E<C=n
z`mp}Eb?v7Gb%iMG=X8dqZFM@dFq}*5G6r4X{3Pp*Qo`86d!s0wTb4QRCo0!zB8AL2
zSF4mxi}Rc|JLZwrDmfl$k)v%HZHCb#t?Hzbpo()6Kfr}$8j51(NamN;mFhO@x{jcL
z|6kX@!c}$EBD$51#??P-{kNV~k8nG?rKf}*DOozlS(cg{+e|g_x7m))a(xYTMS|+f
z*HF-QFjhY&@!K0a6Z-zTXH=8A$r}C4p^=-c>9rL=!&X-jR&?u#4c&a6OE0gkx`B4X
z>>?=O563qgopzmO(;s00I2(l&P<nbi#FwBPR22CuA~o-H)^ZB=$}CF%li7ejRa<DK
zbn_h)6Pq#itO0D}PuTt)w*Ph(AAI)R7X^Fj)!EvE`#<0N@$4xeyjaEZO-}y;{;4qe

literal 0
HcmV?d00001

diff --git a/technical-fundamentals/python/coding/problems/__pycache__/35_validate_bst.cpython-314.pyc b/technical-fundamentals/python/coding/problems/__pycache__/35_validate_bst.cpython-314.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..06e261fb6bf63ee9cef7bc2b4d7eb74eb090f142
GIT binary patch
literal 1389
zcmZ`&&2Jk;6o0c{UOQ>yws8|RpaxPUm^Rr|EfNRBg#)RC46H(PsGQMeJ#MyaX5HCw
zD(AEk2=!19|3+{8DR3)$0mP{{M{boX?~T1QRALTq-<$XL{eJIbZeG0506gxyualYu
z@HZLN@umu!^ie5bA3}Byc9>?@Nw@A<JGQoW9PRA5+Pw~4`#lKlyKMTG_F90pvjm~r
zb-LcIYgJl+yY?)m7JBHfEkWAUe(0}3yZ(|~ZC1`jQf4~RNhb5QUDkF-193l6W$kkz
zg-YVm|8hXiC@tA;{3bWREIFI3<81+5&@2RP?KiX?x}k-DHUXwgJE5c9kRhyB`nyVq
zPSz8hm@1f60n`Ib$R;;Tviq=aef&K@5AWWAuh}6BS!jiJ=wNCmuqo9`>?4%!ag+{)
zs*&!bqOVVuD#8yoDy#>)-HmSPs^sCJeoj?;{Y)K2Iw$z|%QW~V7b*|%COOW7uT=I(
z#5xadZ*PAaBvK1?oQNlzN<_U;phbKrlQ>E@`$O4_j)c@vng@fCKFnkgXT3x|3<fGY
zNX1be-1&$j!K4>y!4Go1H5irioX>hLI4@fj$F1|%bI2?I07U_3;JYiQB>r4zj$QnY
zJy=*D*GTiBxp7)YZGy27J0xd^x`W-TPd-GYfW4-yJg~PatG>hDwxmdNLRf?6tkbsD
zJlg64iHj)OPU++#?Z0)M6Wlr;bqSTy=RA>##+ojjt7&>=>bZhZ1&rt6>dLdmi^b(<
z^%t#cKQ+`MLD+BL3{2bVbZA{Tm)K)W+Ti>s>kU)Vv4xL^Q9AQ1aNbW;uG2&cnQ^X`
ziB602oc22Ak=80X7;2HDZvlM<(U4YkGD*<$%&F`j;LI`&MKKK|_kWg^>Nd-|ib?_h
zzpR0Ui|Q(>zH}rm{YmTJ<*a&yyV)&0CG=3q(mBYo)NpJw)x_VX8#?8B8Er-4DmhkA
z&~`9ZKPB<&(ycLle_1r9p>9}XoH;ad!<yb&0W@qynJTzd)D7Hhp7ZAySKUCb!F5q7
z;CIJ22%UDFCet4xeVmL!04O~@8sIBX4jPK$6+xOeI&C;5dutM<|H*W`pQ;V?64`tU
v#n@(yz4n2v{Q;Z5!RBAi+|$p#`=Vg4ygFNX`sC-wKc2h-RL_>Nc*E%*|L`vJ

literal 0
HcmV?d00001

diff --git a/technical-fundamentals/python/coding/problems/__pycache__/36_successor.cpython-314.pyc b/technical-fundamentals/python/coding/problems/__pycache__/36_successor.cpython-314.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..1c82ffeab03c058851f4c6c3b7e47becfdd68b78
GIT binary patch
literal 1446
zcmZ`(Pj4GV6o2ELU9asne*ib7P1KfDNi9e=KvjW+5E2JcfefrdbEurvc0FzuHnZ-`
zIF)m<1VTL&)UVMmz~_KlnF}CJy*YBLTzPNTE&;V8`R#A!y?K9s<G1I|)&ZBl@;v>e
z0`NC&X3Hx9oAeNjU=Koe6SkRQmk3vGR<<4EY;(i6UE^MYj&lV<=Q=BI8LtVr=SvW}
z9p3TYxiE7JaNU{OR6`H-)g{Olj34@|(5gKpRg2k1EM;zDljc&l99!KP_QkDO+3IIP
z3Y8|-|FTcYIJ0ag`PVnV)H$21;pqrEU|0yIvez(9=!O*x=up6n86I-uh77}c*56S=
zwDYcLCse_-3h)u5LpHfqIJ*UVl@ERZ=;GNje9iV*$ihnKgdAP-&<lCM(OvZ^_7bdn
z7-s{as)Ttadgf?pmh|oQS-jgjo%N1&ReE>dSg#)|A<bjzfY-~_L2NXo@|I15Z?sT4
zz?1Y)2VbfDTag$Yyt}paU64v6)L|;_ZzvIWhk+5vzD$!i+vp8sH$Fg@ai)X*(Cp_j
zNb+tf?*@I9-^s**4&J{J=|PeRt#h^6AKEifG;O|!BHNrLx_SEe3?`-DLotFAsJko2
zB>tRV7`yl#doaH?t`hQLVSQX9RENcD#|=aiyakC%a=NHl*wEVK27(dnF36b%b}!4>
zC}4L>l4Y@WKatZp1B9>&k6F9L6=kK)l9(egkD}#Tu0_^+nNCv@YqZpBh^!w)sZ0$P
zy?CnV@~9~IJX(!lJO}44KCC}^<NU+glja3P=azqNs3t|@Wq68Q=0NvaPP^SEjzy8g
zVW9td6dmN<K}HzceQywFQ_Xx7^-`rxmP#S>C{k~t1KW%uO^+doVq;W#XJCXz-2#Q7
zxJCY|Mu<cMf0`oy2q%@I<tR!+QvZkH91jYHUq&#3S2H}QAhTUXzAcydQjQw4E+L1l
zr-T_OdDMJC@l)DPk!p*nMZ8@yx=i_X+$$1ProM=R2*p_Kn8c&c$MpI2>W9U)sGvw5
z?TSU*D3YiDs!_oNwS;gM?h4`}+;qaV7erTAQB?#b5{%$??icRctr|_IH^5?WI*M3k
zJu~d%lTjQuitH7|D;{>)baM8;X;}ZGa>O62b<|R(dK1OiVT?Vm16%zAHhzPRzj))p
dr{8}uV$Zw=TX}H*(Y>FJo&my>Wh}kO=^rQ=J4FBh

literal 0
HcmV?d00001

diff --git a/technical-fundamentals/python/coding/problems/__pycache__/37_build_order.cpython-314.pyc b/technical-fundamentals/python/coding/problems/__pycache__/37_build_order.cpython-314.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f50169a18fc0d7300a69010d47e2e98bd493b0d9
GIT binary patch
literal 766
zcmZuv&ubGw6n?XlUDKMzY7d2=6k4c+TBj001?|a03sQ8Uo<f)H?z9=ZnGG|ON>1h=
z=)vCdFL)62CjKX025)-ltszLRzS)`@p%32MdEb2R=gwMnZWd4~w|<Lv9>7oMOa%Qx
zM$7o=!ybfW8@7lcTb}WjAoLa?q>GTv8yc2YpzfbKdfl_7XF?n6?@E!&gdpbBNg0)*
zj=rJk!%Nun9=-)g5xWU5NQ;D|i8trcoYaRqwFw4Tb&7ETU(Wq6jy6jZ`c#HXYy8XB
z@TPMxic^+OU5qVvRQ`%5M%zltJ6xt*CW31lC~mq+)~RxXTB?mwu5g{$;2>A+*l4$n
zWqZVSHCLJ;B91kC{x==Fx3O`=gfv_o3;udt@i^@<!;_X2Nt~@8bY&X1xioR6S*K@O
zxnxP63VFz|qy3DxHETSG_PZiWqg<t2-R<;jC5mDxa}ygLMQRQkm`Bx5(DY#pl*|mB
z`BA+wXq<>M>dv><K0p1s@MZhso5KI)&wjW+peK(8$@|Uker@O@X@m(NxmY4PZn)wX
z2YBd12rD@H&L?~p>Ix#tJpt_kR##O8KlbWWtLi!;MQ4uNhhYHzjH=>!r(Uvw>2+|<
sVzI?e3%YXrf^(j){J5Q`-HdOl1-x+W=xb=sC?RBA1F|#@u<;_`53mW8oB#j-

literal 0
HcmV?d00001

diff --git a/technical-fundamentals/python/coding/problems/__pycache__/38_first_common_ancestor.cpython-314.pyc b/technical-fundamentals/python/coding/problems/__pycache__/38_first_common_ancestor.cpython-314.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b77fb998fd283a5b97bf2fff880862d309291b8d
GIT binary patch
literal 1463
zcmaJ=&2Jk;6o0c{UOR5$ez=JmP}&BP8b~&X9(q7rIFL%nz$!F{%2{pK<7Ufx)|nZn
za!!^&sE301H~Qyri}pe*PQBT3t6X_+*PDh4F^Av2kJ<P6n@<-n)d0`phi~Io2EgB>
zl*cIqHtV4<h6C`~eb{B1t&wcpH+D^J?poT~wY9wl9rG6W=3Q3&rJW|AZY_gvcdU-{
z*^M$Rz+H2Gr{X*4uPj5-(5~;UL#z6lTrHL@ghHe`)Nv|Q%gic!qXB;q%B=DY7hJ|s
z=6*LIXP9JcFM1anU>=;!HqbhT4ru0sHV*3A^ljh3geE0Sn6`XN+djjzPUh}O&f961
zw<GFc-UZMMFd&<Klm~kN2gbc$0J>=V0DfSH%xAvgo4$piEzhJ-uW^o$*~eir<g!At
zmGGWESuP8HxLM|UxYyb2WVVbSAL<v>wbM&wKh%oS-_C~KkBUp>p(Q?6-uE(n!XvG`
z&v$ly@?xR6JdXL(Ey=^~$kRMJ6mb+LTfL#^hJ7w{m?&>B(ub+=qO==}$KF7uj}qQj
z-WT_RUM!UkqO{*nMG%UJE1k;i!6>T-sOH1xL69}eVz)1vFJXb|4#F7Dz_nMW1TU8w
z6C1x12bMM_6_Q+NY)-2v&G0Tn7UBHRm~f2M*(WHBVZR|t5A5F*<pN-TN6^ju_^=Ky
zSi5D)I_i>&kc$W{E3*_&dheMPrQ5(GFQbsTK@f{rV^5ba^i-Jgey-xJF-+=kef4?m
z^xDev>S^=F?=^XiQkd`3<!M?*yG^_a0)fNEptT_Ar`=&fGLG<Q7$$SiQcw&#i3JyF
z5XcoOrx^r_2p$EY)-rxH)Lfx&34M9Syl7b^m4G@{1i!+Wkq;E1xJd4QvDQUH&e~!_
z|Ib?A@eR*H=2qka{+C%YP4!9hoUP@okgT1I4Nev=7&3O0Ig;z46nWt-CL0)|;BV2u
z71SjGHLZ3Kh%z>-P6<wHYZDW{FDq9jHhz&h?$t?!Bp003X%(fs$q4&7KSYkaKYE^H
zAX>=lC>AxC@+Qf*2yP=N`t_Uz&Hv=R{21@#71E0x!?Xr=k+|Ke(rSA{Y!X*1DOl#{
z(E#6*v`~>Y0acQ}_F`ic?!8rJ?w18WzLK;S>OpNIOiaeu+d8oIzhLW6*m`9xJp20R
ZZ^!J7Q)R2qp8j$4+sPY1@oc3W#y@G5L>vGB

literal 0
HcmV?d00001

diff --git a/technical-fundamentals/python/coding/problems/__pycache__/39_bst_sequences.cpython-314.pyc b/technical-fundamentals/python/coding/problems/__pycache__/39_bst_sequences.cpython-314.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f63b3bce2a8cfe58676b4230475613beb4301ba2
GIT binary patch
literal 1404
zcmZ`&&2Jk;6o0c{UORD<(3+G4l$KNp2AT~@4<I2f9B`$|z{+h7k+a&Y$IX`YtTQuC
z<(w>mP!9!h<WHb~50|nRK%9DW<W@Ptdt+PukeI{UH}l@U-|u~Wbg5baJS*?LNdL6}
z{-MkKcvFQ<9-uOULkQVzXfVw-NVjfV4O`m{M>`EyyA4l!8_>3|LulV((?4~o26%T?
zA#~eLyY%teJT$;9d*<VZ9@<N*kS*(S=x;*3{ESR>RxHFq<T}=AE>ztqO08j^--~5Y
z`icuK)1>gf?vpXj3g=F$birE5O9X%!1e<K(>j>JQSqR!XysYie4K0MV2{vQe2_5Z*
z48gs^Z%NLZd51R>%43!bP&F_ho7^zL?!lq;=??%Me0vwZWydUJp%vPpgQ1<krclqY
zqENV}aW>%6C*8?-SD&rUX&-FQu?|}8?RMeH^!~AaLb-e0T=rtE2>$(|7u;1`ssLZo
zQx$w8^9MZ9D)?k~_q!k!n#<FaKfEb<+!+R%C&wa9;_PO3AUbi63ms=F=nwUAE`lWQ
zq~d<im-$h~dn(xbEILv;Qv77VMZ(oie^@L=(X8}5ii+Bt<j$+lSCE+c0L2I{z<1Zr
zN&L06Ja+Lr_F!piTq4bf<?Zt_Y7_K@#34C5R30o}dGaADBiLUSa|`TW6Z68u{;nWT
zb3)jJC#+ewWfkx85{V@gI3AATS@(@+MQ~eq<Xfl|eiWr5)tJ-DD>+S{Og@*<YXsv(
zczgYE<>{5HkIPSMYd=?HjUeooa0aGsHJdaqQ6#X)7_<^ay}UEXNXHVM4B~8NS&E`=
zDwWPs!9^ZL@*Sd6iy}qiokX$LGCdk-uF$rOHiKwLOIlDPh@4tP@grPVrl2UMj^y*&
zv{K$?TCbrpg8!e^z`{v&C50^<ndka!VO|=X$-<Ld52QG&(taHn(Q3C1#X6HK_}6qo
zr&NidB(XsT+IAWa#>(d;eq9*T=eMf48RCXBx|u@_H=JqJMnJ8WtEkS=uA^?yX5Fm5
zHn;KynhmaNe*eSq4MekEp~iFvm<KjSA_5ei9`<nyq=Oep{*o|di3Ba`wCEJ^jcyeF
z=hGH{A-B;=l+_N3vCSBJu?B4OPuTk%_WpJj9)0=!oe_KPmD&2EhrgWsboLxjy|{`c
HFvR`?%cC>V

literal 0
HcmV?d00001

diff --git a/technical-fundamentals/python/coding/problems/__pycache__/41_triple_steps.cpython-314.pyc b/technical-fundamentals/python/coding/problems/__pycache__/41_triple_steps.cpython-314.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..a6f58d0b09cfeb16fb4a94bb9ca7aed22a50c5b2
GIT binary patch
literal 500
zcmYjO!AiqG5S>kHZM7}pr677y5Q@~T)Po1{6N(1(B!-x5Z8X`0*=?n_9{dE4{(zrk
zuAaPAiuCGCs_4MHefuUaGnpJT8*4z(+WCrv0C?xiZ#X|>zDZ;XF0{ZEEr>TPxXvE5
zO9456lcP*oqMUaLrf>x}&dC!%NZK}Bh@o)BHC2}3I)7Xi@A}|wxzKq9l^vmOi@X$R
zOGjmpV&YrFjdt@`UK)i)k`j%LJje821=h%;ZudcwLE$)3j~!HgIFVKbLmdTv+!>5?
z=qE~BKQ=O(*kP(=kcN@IlNqMBu}X|QKJqL^S*$!`Rb~#eNnZCnU+dKRR(T%QXo6Kr
zvqdn41qf05WO(k)_;~3Rw>edz*bNg79=+I2g$QqwwkP_p1Xw1e__Tej63y5DjereO
uiiRtN@2y-#{#||YaS7`TtSr6N(<BW?u{y&hY24IsaaIySESfZ6@$5H3f@vlI

literal 0
HcmV?d00001

diff --git a/technical-fundamentals/python/coding/problems/__pycache__/42_robot_in_a_grid.cpython-314.pyc b/technical-fundamentals/python/coding/problems/__pycache__/42_robot_in_a_grid.cpython-314.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..d9fd068ff11a463beed270bf0325fc65edfb48bf
GIT binary patch
literal 769
zcmZ8fL2DC16n?Y2*`&5jixvZ+A{Z?VTDR5;9>kMk6sdKwo{}!xWZG=q%!JuVCAU3z
z@KVSR@aRFIf5t;V=OlRQtr{d(-`g69zU96B-kY5_-}`277UwSjTKUTF=obU{LCM6N
zzhHETAcbA<*;A-7&1#mmYPPnoLWAMs+$vAD08C?@!&R%{Hr%_`bbT7@yl<7jw@VN&
z>Vof7pqe|Sc2(Or&!a?}+^b$U<|elzA}N|k63EG1bQ^u-V@TmO>{|EV0kp8T3@=%m
z`K*pB=jK~=Yl7>O(V$K}GW(aJXCV>$ly(^BKt(O%Dz1A<R2}0y!Cd9CrR`9+jk70Z
zTxG`Hm#P!$g!o-E(%VV6N<6GYM~Szs<RNeB#JjV;{>F=h=ISWoZ`TwLTYXRSW?Mwf
zFkaj5iB{O*LWgnUb^E$4h1Zm=NE~=wCHG?9NxaRC0HM@DB!Vy?dbhiMGZzG*5K@Pl
z2Z35Z67%Ru1w#sBU~J|mg%8)y==Jg5$<m4bR326~v+@W(gG^omWHd%5FKLv54=4%S
z`iwypu#%0rqKXL3!hdwsC9GzrlT0ama|&t^(N=ZFxVqoPX%w|qbP<`9YK{>7jK)TB
z)GVdcMO~yoo6nCbJm|<)FXj)`Wvmg$WCO#Q%@`XOfvtRj8{hM@?;j18j-L(lrPTR~
X+2cWFkPKFjUkvlhsWWy_fUM^qfMKBn

literal 0
HcmV?d00001

diff --git a/technical-fundamentals/python/coding/problems/__pycache__/43_magic_index.cpython-314.pyc b/technical-fundamentals/python/coding/problems/__pycache__/43_magic_index.cpython-314.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..874e938c9e8edc170554dd7fa64ec8ddc8621ed9
GIT binary patch
literal 973
zcmc&yO>fgc5S_IX6QC{SOKlMmQX(Nm&~6bufP}bkDH1AR3B)1Pa_voH>a3&jrjT0>
z{1keK)FZw15AYN4l~Zr6qAFKrHbkw|-Wh4f&$BzbZ{EzKx!G$#R;`{UzXZS^{+XKd
z4~$j_3}6#{@fy~J5$ld|9)RyGfbT9qI&WORM7V5m$@l8exN^kF4W}r*Npe$E-gZrr
z=`fAx5#YsErsdKaHOUR&BWya)z5~P*yASV0Tlj)^Cf1zNfyeizF(4An()9206Vj=}
z&^_Yp!VM7%50&Ym9=gbH7jB{r@*NFPc&!XOp~;zGt=N$ta)r61NV1#DcbI)qk;&zg
z)zuwISqgU(^>rCl826=7QClZbm@c<^Iu1KZn=s8~w{O~+mQfZbdRule+e%d@mupXh
zPPm;!L84>zZKc~UW`ZEpIy0eBL4b2a;5x0mMs5IO5aQ|yyB}-&?%wlbhCde%>jzaE
z9nmSU(lTJ<3aqpqfdTkHB8ZJ4Ijm5`R`?KS2^LE&B5|Hh5L3$%9T~hs`%GiRof^RJ
zQUz}i`aexXE(Lj98v<wOGij48!U|>`^Sh{;*?+aypQ!ffFgo~bRXeMNa;#mV8s4NG
zyv6P|x%0wRF9@eIeJ0)_9cMOpmmQ;xM!E1zze}TFXU~qE6&d;P<Q1D@8&i4F$>LtB
dULp@XbIZ9Q$F2}!JP)FF>d_dCE9C6;e*uWew#5Jd

literal 0
HcmV?d00001

diff --git a/technical-fundamentals/python/coding/problems/__pycache__/44_power_set.cpython-314.pyc b/technical-fundamentals/python/coding/problems/__pycache__/44_power_set.cpython-314.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..cc38987d638ee87542290166e70d8bcfe74d4b46
GIT binary patch
literal 621
zcmZuuy-OTX5TCbuE}j}cFrW!hApzkq<|$lZ5mH%12%-yGiOXj9>8<X)UFN-0uJVff
z3ECxHQV98nvTZ6m!y#H`=IM!r12b>F=Qs0~#$Sv8(ZbwKc1Q1DHU{K9DE)a-daw_n
z*nrQ%iUkP083_Fu$S18A*4{y5=!%mYqN;t#j7<a?%uE5XPuxcmJ=lePZ|xgEO1?L+
zEm|TJdlb2+y}?j;|9ap98uujQ(fxex(>m!9H2;cwR>D*PD%(Nb@R0FTex@xU4h{-z
z$JQ|3w^b&0j6x&Hlbsm3g~gFdtdXlLE60)w6rN=2bQx8gcBNHGOJ_-(FCTPt8n>0U
zac*SUwXH(Sq)0P;C`&B9=BjOEvl*4eslv!8`=RVsV^I`qUD(*FD8f-1&ukV+^xzhR
zsQ+Ve{_;Gzcy-O{cl&ew_w=ugA7?Jor%Z6SW`&7&aJS~8_aFq?Uu<5IK=!yD7m>fb
zsy|}E39{YjAy@UMHjHDWZ8rQWu-%fDa0hdFI8G54zHc-9v0bE{Tz$eR3h;cx?XG<x
O#LXm#+1r4CyMq7xHG13t

literal 0
HcmV?d00001

diff --git a/technical-fundamentals/python/coding/problems/__pycache__/45_recursive_multiply.cpython-314.pyc b/technical-fundamentals/python/coding/problems/__pycache__/45_recursive_multiply.cpython-314.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..066c77c16f8f62ab1b6b404064c1eeb63db8d737
GIT binary patch
literal 541
zcmZWl%}T>S5S~qH{jbuC7X`IY2vWC#f`{TGhz9f|hL~(^G})BdO(nM+d<>6X1YgKp
zJ$X}#cy%_lC^#@P-~8_Ex6@c&0Fup(&uE(gyqaJt)(;pr2^8SM8n|o?;#Cc<)dI&3
zXabBHsgv5I;~tp;&f(HJyaxy=w+^Rlz+84gm5I34A8h|(Zqwe{n|Zlpe#x%NItrbk
zbXaLeQj@FqQ%roV%)8qq@-rn+amqv^#ZNH35rI~GuiL%lG$3#kiMtL8Kg_un!9YfV
zA9wnh4E;n%?Z=7_b3I5U57ID_*L;ZSRV)(4_YXW2L53<C2`|ZF9S!4rcbJz;p65%M
zYF`V_L&M)JsoEk_z!xw!|6$BS>)p7=iF<BU$uTuSFlE*R<{uSrhCstIF~E+Wz_GAK
z8Jr=b%s{)1^W@6r|EsV;h3W{?UBF9i4i^a>JFF_<G6hv;vSO~6q+u3|BV3_^xj>n3
OyxWYiuLd1m^?n1z%X4A?

literal 0
HcmV?d00001

diff --git a/technical-fundamentals/python/coding/problems/__pycache__/46_towers_of_hanoi.cpython-314.pyc b/technical-fundamentals/python/coding/problems/__pycache__/46_towers_of_hanoi.cpython-314.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..1c64b9912d23610ca8dfa0972c2348f5beb4c99d
GIT binary patch
literal 671
zcmZuvy=xRv5TCbS-pM6KEFuy)@FTEjd=aBW5IZ4)1YM2QCCj?|&RgAkZ+Y)+!gX6%
z*w|TGY9UzqhuB!Sm0*=Fa>%vLY`j8oU}k=AzV<i6URhi?2`HD&|H?l&06*w47ksxe
z-9T5v9z^UuY%$BW9P9L9m+iV&&;6-EXT8W-hR9upV#)fEcM(GWkkX;kcn@-88~;gF
z79wRBBPBV3>Y`2uXli&0d(P%7fDB_R@Q96A#3*wtku#Wcf`K=W{tw;wiy3#2i+f1D
z4U<ivg{`y<-NwzO)iemHsRN-y)&xVP$B8vW@Is^bjuF~$jO6=<Kh)}lNUh=5*VkWi
zY!-Sy7YA!vB-w;pk&a}ZCdJyYl36kq(k6xB<;0GZ<f+PX`J9(pJuAf6@QqusrEi*8
z4dYQFRer6UG`%=Zq*OMsB98R}k~o8ER?*Zj1ID^P$-Fg3<la^9cRt<weDllY&9D92
zZDxv<(4Lq832oAzI6zQC1b7U#{Sl3(>$jV(>K?-8)IW^$X^gf6{I>U-*U^iJw!@$a
z?4-nnG>vX=sJn#dcWT@85+SNSp53`KR#{buyP5_PDRUOhk;@pHtpMwP@AO_je$%b}
KS%9mxoxcGTrHmN>

literal 0
HcmV?d00001

diff --git a/technical-fundamentals/python/coding/problems/__pycache__/47_permutations_with_dups.cpython-314.pyc b/technical-fundamentals/python/coding/problems/__pycache__/47_permutations_with_dups.cpython-314.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..bff37c5fe0b0693fd2c90adac30933c73a47267b
GIT binary patch
literal 899
zcmcIiO>fgc5S_JCH-&x#S`mWykf>BCv}KDxf&=1+KtdH*f>Tw?*jr+7Y-@I%Dz_Z?
z863+YQuqh_5q#y;TTvAC%FKqSNa4yz^E{pz&%S-*?bVe_K(=*jl6)5cKlx>5&Yxg>
zkAeXlf-hde3t_|^@SP_3ZWGdmar_#^3pRFrZxh;!r~F}CRJB)$HW7^lcD4m_mwf!3
zU;yvn(0TG1Ag0_+cq2N(7Y9_Cn(rLUD8NN_=f<oKAe~JZx~JS#30--pOo`dhsa$Ok
z`5<E99p%^!jb;vatDbzT6>3SDq^IR;%s;BgX!&4o?~_b2qp+8#<6Tr?+?Pg0oh*sM
zboZ#t;;^eS6Q)`gebdP^8Rc=3eUJs_?^D&)^3mg<P}nUEjm|S294Dp|#ATuH7yW8E
z2*NDOsiuMeSBT4Ha($a%0OugY(l3US^)r5qHb&96md%W*1FVP~u<=E#h#mz4@PR}S
z`$Ga;q>R1j7A{j*wdM%rrLmlFo$5?s%sUytk6Im9Df-{*LOu?c2-*Uz1a>c$u9d~Y
z8rA2t`4U-ePU6wSuZh*>f-&`5`-e8zpbB1LxJvN1JlE#rnQGIdKBj;h3@pojyH<Io
yU(mwse`V!E?wd~Lo~h*Zr`<d*Q}qm6lw&@cr<}P$h)Dy)^@&FdKCctl$-e=f!mVEb

literal 0
HcmV?d00001

diff --git a/technical-fundamentals/python/coding/problems/__pycache__/48_coin_change.cpython-314.pyc b/technical-fundamentals/python/coding/problems/__pycache__/48_coin_change.cpython-314.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..69e0693f2e71eaf9c709f04713e299e71aabe93d
GIT binary patch
literal 610
zcmYjNzfToG5T3nz??eG1T3`%fB9Y_}Tudk^43z~Wgy<zu5iaZ9^4`ha?#t{x%<Hb;
z&#=_O#FBr;ZK>!mFND_FB~P4Wetk2u^X<HOJo^YpR$tsyy$ImaCljGO$asld3&)VL
zUD#oky@V`UfGl2sdfrA^XBpD&m2XX%>+Ds=7K{?FUJ}xnbexfC;Si3at#g2qutoU9
z`YdBdRJoHZI-0D7dvxvjqz<(99_KNw?p*l^mxx9Wm37@hSIW2qr5&P5BNtc7q9;J?
zk`s-Mu*P$H<xcs5k!Uy})tTWRQGbzzHT>Pi#wn*MiD#Akx{gwmBW`8US5+bE^^>70
zMI)6Jwc&%2?Q6vgT~?~c2dF>SvN3#fEB8F|qAyfWz8#F*Or8s+v=vt7InEG)C#2>z
znHFw=v4?-W`4(S$_x;1Kr$2T>c(EJ`V`_xr-*G7Mp9qKb7j7W~ItJVS32B5L!3SiF
zA6QwzX>xA*KT0@HNMO*VpoQO^DV(KfKaE{tM+5pzI9lk#IjV&6-9uCF8(j`-xsCn>
W&%^kR>zFZivjptfZ9;zt1AhTDmwveb

literal 0
HcmV?d00001

diff --git a/technical-fundamentals/python/coding/problems/__pycache__/__init__.cpython-314.pyc b/technical-fundamentals/python/coding/problems/__pycache__/__init__.cpython-314.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..d2e5233c6ac9c8aef2a57c1993c57701ccee4603
GIT binary patch
literal 200
zcmXwzK?=e!5JeM<B7z=5S0XxfFCIZea2;YZ+GvxMB&~Gkb-Yry-oUQhnSj2<%=^q@
z{$es7k${_iWZbVf{?MOvgCGxbATu(jyC<=|kh^$n5snV61I4|p9qg^SV&)yJ)AR;X
zd$hI0`_dv84S39QEi+y$&y^Njq4vCRP&Pg{8ZslKzCdZssX*m`F{!0zY*jYxaHEW<
T3f$U$_!@h;DDQ+)YLj4J>321p

literal 0
HcmV?d00001

diff --git a/technical-fundamentals/python/coding/problems/tests/__init__.py b/technical-fundamentals/python/coding/problems/tests/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/technical-fundamentals/python/coding/problems/tests/__pycache__/__init__.cpython-314.pyc b/technical-fundamentals/python/coding/problems/tests/__pycache__/__init__.cpython-314.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..5ff4d2184d2dfd0bf3aeaf0cac34e28795600378
GIT binary patch
literal 206
zcmXwzK?=e!5JeM<B7z=5S0Z)lUOa+`;JU<iw6SecGHInduj7@v^#*q3&II%?{=8v^
zKeL)mC(McFAL;AM+h6<#{m8+C9od2{`Tohw!1cW!b~&5~4M8caYzPiU-!QQRn<&ab
zDvPF(cn=MVv;~Vvreq?D@KUQ(l&GvI2&&d*T0x>ysjg5NeJ-#hw@of6j-`?|j@MP&
Yjkl#v>jHOX=x+P($iq9}oSVSW7h{z;1ONa4

literal 0
HcmV?d00001

diff --git a/technical-fundamentals/python/coding/problems/tests/__pycache__/conftest.cpython-314-pytest-9.0.3.pyc b/technical-fundamentals/python/coding/problems/tests/__pycache__/conftest.cpython-314-pytest-9.0.3.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..90c2075d9e4911685296b783caa26fe2cf97c212
GIT binary patch
literal 1273
zcmah}&2Q936n|qo$!>Nx8x~4hXq7a4s4J3~0FgLUp+XcT3bb1T%O$Mkc)hHP*S5y9
zKq^`p2??Pd;MhYC9O;c?5B&qUu9j${5vb~sTdSzz+V|{r5>=J@q<Qn^ef%{3&3isI
zQ5pvn<CDML?-_tihfLI=vBS}bp#cV41;LVCSy8*nG^}W1WIBzEiZP5RtGSiD$WOzq
z{HJhh{2XGE)DEZne%)YmNA}L5XsA<QXj9-#iju*OL3QLEg}<sYsnsmewh3#92MXGB
zzn$Z#VyHtyIsXWtiN25F8`fq9TgON$I-x1=s7B^muIKnx$3a*%5*)YDR=_)!hzNUD
z-qCMF4v%#7xOXGH#)EGiTSWTe>C<;~*B1`I>pJ)5xnngqb>Y};-?c4ozSZ@ci0TW=
zi}Y|)v;$wagQn}>)<Yg_cupt6><EGEz;BVY5N^t%X<EJ?2unDo$@6%DF<j9>R584V
z5mxz&)X!&=Z3o?u&_D*s2(E;NLwI?jp_UPpgi~eU!=0m#NBPgVVyIa>Wb4CB%+=DG
z{klf?`<K+&dM<O-VXlzb0K2Hl|Df)x$*Sv0);ytFS8Bz~zqi-Qdv<2k)vRh7>MB0F
z_MJ*ZgJkoPnbn*e<4)*Vwj=XyCk(jo+zqL9h3m<wD0FPI#e<GXO=5b1jXe<fvRE^|
zzIf%!tJlm+tA?EH1kEmnlSC?!qh4S&9WD#beFR9uRgKf*$igt2T25+ddg_XZ-jg#k
zGo09yMFKI0y~1fSl2*8lMhx4PBZJCpuQL05>BVfnGC!y+^(sp*?O)IKD;MImH-$q_
zm!B*T3X8qM;>%ONJ$TjLx=`;IZpN41lny^_JZTI{bG_2si|hT;nfUUymV3PRaBZL+
z?P*7Uy8K!@wp}<7U*+^Gs7}b-M%VR(>qoNqMYw71o<1_Muc>jZ2q%P?S>Vn+?h52`
z*G2rMzHuz3bkpK;VwdX$qMA?A7mtNF)kr^22h&VhH_6X&kRncFkTCHJBzH@R%6*>l
zx6DssoccYgqWV*1jQtMq2>S5BTlnyg^1){-KmIT%pXilOJh!&WpT))Zqc}_n)IUMC
BA!Psn

literal 0
HcmV?d00001

diff --git a/technical-fundamentals/python/coding/problems/tests/lists/__init__.py b/technical-fundamentals/python/coding/problems/tests/lists/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/technical-fundamentals/python/coding/problems/tests/lists/__pycache__/__init__.cpython-314.pyc b/technical-fundamentals/python/coding/problems/tests/lists/__pycache__/__init__.cpython-314.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b6932354d62e980bee3a87e61434cf2d8026b68d
GIT binary patch
literal 212
zcmXwz!43g25QbYqM8XreIf*db#UqGFoSWJmcIdXNEwVRPkK&c~>J4n%wF&>>pKmgg
zKmWMj>$0H7;6rh~qW#5xP`3lz*@g|-h_9Z^Ho{)VV|9kDL+c=yo~{no)*LbM4(7Aj
z2}paiSHj!GqD)Khm}Hs~sV4i2PGyeTOXZ*_eP%QyCMA7<!kV4J+=Xu!f)qs;f;4#{
brbStG7P(0;3YWGO8pMt+!n?^ix6MFb^#(e0

literal 0
HcmV?d00001

diff --git a/technical-fundamentals/python/coding/problems/tests/lists/__pycache__/test_11_remove_dups.cpython-314-pytest-9.0.3.pyc b/technical-fundamentals/python/coding/problems/tests/lists/__pycache__/test_11_remove_dups.cpython-314-pytest-9.0.3.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..70129e5c7de7fec2bb040967d80fee9af8ee4e21
GIT binary patch
literal 8120
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

literal 0
HcmV?d00001

diff --git a/technical-fundamentals/python/coding/problems/tests/lists/__pycache__/test_12_kth_to_last.cpython-314-pytest-9.0.3.pyc b/technical-fundamentals/python/coding/problems/tests/lists/__pycache__/test_12_kth_to_last.cpython-314-pytest-9.0.3.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..e39906b6210349bf9dc260e0e7a4d6371230b326
GIT binary patch
literal 6787
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

literal 0
HcmV?d00001

diff --git a/technical-fundamentals/python/coding/problems/tests/lists/__pycache__/test_13_delete_middle_node.cpython-314-pytest-9.0.3.pyc b/technical-fundamentals/python/coding/problems/tests/lists/__pycache__/test_13_delete_middle_node.cpython-314-pytest-9.0.3.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..cfd5cc1b819bef933d79c73f7039ca501df97c41
GIT binary patch
literal 10016
zcmeGiT~iy^^{%v%Rv$<P8)Mf_5q2=hU<3w#)xq&+Y{xNCwu#aY+dHzffLb9fcNY_5
zccM(%G1Q)cP991pFHENo;jKTQPkm@J)9DNtVwfE=na=dZZ>f1mo4)j%yV?(wwE<_E
z<bfUO?78=zbNBAO=bo>-ZPA(#f$Q(v|C9e)fRHQ}%!{uetA7EcOl}a7yG%5W-94AQ
zBc4WbiPwCMMvGqyK#S+Ha4Dz-8_D%x6S*Gh;fy{~JIzk*`wdU~_w14u5xosWtGQm&
zL`2@?)1ud-sqfoVCZ@%pK5mxmyS7dAK`*uS1bXo|5HZl>F<P}ck=sua!ecD<B{-c=
zWwgO;Wqgdr2ha=u)j0rVa*b6YNLBi<DzFZztFAP;<~OU-q&;lngqWjHxOI9B+B_zf
z=FHhpJZUb)*2`=&?x~u!Wh|vVCRZci`^hZVmk8*={E$+jS|NW^=SQ@BL2pnMIV<(k
z(vZ}jFUV4%l+9@QQc({|De?8QuU)wMLw(y&DK`Rbj0)*>f1#Ag$y5)^?*O;aobc)b
zc2Ud>$vV%-ywIZJj2?)`_4ku+sWMfQL(u;%HJPHNpUGKGO?Gv5{ydp4YBIf*mq!m#
zIg`7c)a2}7F`vy84)u=|bI@Z^%M{e4a$6fL6_eRgE?*o-DztR7AP=cPtwKkIJVL~!
zu5KwO7i3MAhVr=_482&&$sNjV-3Kq2$<b{vCXjZbUII`iE8!iJrzTD<g}dg%U4Lx-
z)8&taPhLtbgx@HiUkPoW?3n0S3MJ-4iH}}f2qnwsmU-dcmG`bJ@q6a^J=5nF`S@};
zT7GpE`XXbyp7!iDqK1>gL``7>=pYLBCV}Pkv|uN2<qi_Em%ws61=MJQ<#ZEB=W?ga
zty|&1o8r0B1!4i4fMP2wmp`K@axtg-Ze<E1ux3U19Sy4aL0AIaPi1wapy}T12sPJ`
z#(+@|NQ_>kyP>ol{^}tBWwKloE5EWFik8oP7OGhmqLVcfHB;H&=6{o46ynR#+R4F*
z!C!lq!?oqBv=%tB@V74WHCInTRR(&y4w^<Jn&-w|&AXG7K=;7D=0y)cAJY_mkq11$
z_PZeZwP2cPAu)h^T;K5~NWpm~0auv-^uhYCSpeLdumF+OO8{Z7o6iSbW=<sRRlC;O
zgK4g4)jHa(-3CkMqAgr`yylbKdDiL2(m!eL250FP&oz{5cG((0@pcd~^g1_uF3leY
zksp4`6tfH5zzZm7*94QxO}~IH4X1tGoEUk#r`ywm;sck+iJof_0|$K=H8K0%M0zTP
z6L24Bs(KRc!m6vup+U{rF~^$QQ^j9b#SBF^{;M!f(JS(s8f*2exQ^AHVQY*H8yTa`
z2V>(!pJVo2-zjZLis)aL*0P;RzTL7$u>JjFKorvcB)6tEaIM~)MMuvr*1CzL1LlgD
z_d!k!p5zqoNshiL24Uybj5Qg0SB)ErH;#%op3&k;NzJ2OiFfH<<#s329f);Nm@$G_
zH-e*IMl&jy2`%2-s@y)FP_goOU&2dq(>=zW^%(W$Ecd0Sw|ABs>qNTlgc`b2LE^oP
zwKJi%Vog^<O@w|C?=@<VCe+!8&Z9P<_}+TmSIvYmw9sj=HE2pQRIio55EUdUD>Pdg
zQZiK5BhW0}9LX27d{ISn2o$QmOHv0*BZV9zl?Do>o0)>d>|sz+GyO95phwTJ7lgUE
zKxv8U+ok>z1*0g*?<j>#ky&3*VZ16A`gKpS)0m(zKG2w&!@8qz#98Pu3Pyj&oP`rA
zZg4Qe>@xKD0rq~C^>P|Y2?k@Xm(-=7bW^4s8)JrTMAQ`kW%AFO+Nq}dZ;yLc>UK^I
zf6y}Sc@S7>*fV|RgVAx%WMCrjAhNPIK2!VQMWZ+wnTRY3yH{%W&z${;Tc|xa?q7-R
zoVs=Y-8rG{_Xz+qiTPODl2G|A3T@->S|tm4FlwO>g*HdYs)nAXZdoNDGE0x_9-;G@
zghk^-pvACemQ{eawX6%;m^IeLvLkD(i^F<6kEL+%IIRM|Wffp8;M%eZ>2KF6v=mEm
zrfARt<oj)FkXPfS5iMTokJC(XK&GfKm;$C4^fA>(8xe~m00)B5eE|Aqy^nFf(ftTs
zM9_=?%`j~RFe}h*#L<u$y&OU8D1u`Mjw3*?#6>YCm~JbUj2HrjEam%cg$U!7O8pWW
zuYT(3x^W}?2VelJ9|HjO7~4K|=Kkn7zp`W3bnOQh$N2}rmEA8)XFhBg=O=>`!3R-P
zh37wNTBvQ`QiT}FY{Egd1Mn>e*>Va^H*U*8h8_4#Imic|p$ZGKs>Zd!40y>K)`YYd
z#$KiU=*v*&qS#uWso3!85<VS#zTVC2H3xeK4(Tic7Uw%XBg}7sPZU}G^Rql7XfrN|
zZ9TRZ1BnmbY_ac(_l8SkJMdQ)iCMy)vLalY6XIHd#kIk&#I;tIEoDWxPQEp9tr08Q
zPjZcf?U=7BR<!xni7}0BYG)Wz?(}x7$gfLldj;M#QK4V-iGG(@5wkt)a`e2zth4V=
zi4_B8tO)Dq5@9M{F@PD0R~`9@4X$E{tzvj<6~D<<WVyD;SaX#^!!&GsFawTVv2YuJ
z%yIyRJ~Lze!x+{dSrh9YGh+Q?eN2}@WPb?5_rqpn4~QMvcd!Jc9o8R#u%6RBc{Ra}
zwLgOm6P&;WPA3upS0X|aAhr~et%RZ=(>4U{2r#KhnI=mj)`<WTsDvIyfZ2mYwUg<L
z#k-iF>8$B?2INPbh2t)|`k<Sx#<`VXZY7*s07hb4e|f{&+PwpGi`D-EaJr!mXLC7L
zKY4fJ?wk;x9%f)Z7GDx7zXc&ae%C5l$T)=56^e&IQ7JvLi6JRGJ#5i95unE>-kG>F
zC+wTf86dWANvQl5gni?8tdfP`Gb$7hfud4+WD_r9Zx)RcftIhDDl3RT3M%@!gLr2^
zzSfjkiXSGvay`?OSqAL?n4&dInf)Yp6Jw<-s!W;9=bpy2_$sDsJ$k1pTaR|LrtIsb
zJ)Ne^CEY*VopM`U-wn_3uhIfb!T-*jyMa%uQpT3+VM+xiFdzXRgamxe+dujm3Ha~o
z>I#n3v%BQ@%vfau32?!rtxA9g#Gn{T2dWa_p-m*ft>bL-36KD<NP^;nB>1%Z$s9<7
zi;O5faCbl&z}?xbEJT?s#I|H%UAg%dWr4Xz+s3Nny|wO<Hd<otk!t%#^djtgdI`a0
z1g`?<Lw~7f%y~9)!tj?)7@^-4AOh#-BKkEwrq2XO#b<ho8)f)I)!r0%V)QkmzgM2C
zzqM`_bZ5F*sB<^(YbC<fxx7B?ho$jeM=XWl4FFDW>nKb183#4Sfk;=UiYDDW1c8$f
z;~b=IeNPLPiG4z#>ZhO6)v|i%g(0YafRNbfYdKPW-wn5`c_|hLCvQ$@o;kz7e5`p%
zsQea$<~ei#?HU6|m#b3uP-r$wj{pU44I366jDXLavFM!$v{>$6%TlayKGrxVw9NDv
zAl9-ZRDKIW%UrC{Dq09WxkB<#XfaEV0EKa2!=i%`@R=Tq-iZJMa|&nSbD^*<NbDp}
zlJt;N`Qioeh$Ib<WD0o32c?(<AJI@1KCdatkp7kE4^T2sBRG#hMDSw(dc7p68XWay
z;jB%g`I{pkgU~^(BxMV5%9qP$wX6(hjuL#RRO6@wHq54+W|B+cK%6kJ7Z4S5;s3q|
za`nU$@U=gw^8?t%fX}!8i)g^t`Z)o>-idJ~w(Ej<hRMPmeYa$sdUhBmjgb28pz<iq
zYqB1+s`Nmmjs;74)cT~T1HUMu=<w<R1wO8VuZ$=fKAb!Dagl`e6u#wADY|p)GaTI`
z4H-ItMPm3(iSb@PMGW&t#x50JGCngpMGH`elc4?tz~^3$<31zgmt=v|e@b@!BeHF3
z*Zsbw$iDf=zL~C1BF*LC6F<+z{uL$u@Lafg!FQnSS*~wbsy{eie{hb}EeC@4M&BDP
U^H2PKuI`JvR<3oG0ASDlA5=`9e*gdg

literal 0
HcmV?d00001

diff --git a/technical-fundamentals/python/coding/problems/tests/lists/__pycache__/test_14_partition.cpython-314-pytest-9.0.3.pyc b/technical-fundamentals/python/coding/problems/tests/lists/__pycache__/test_14_partition.cpython-314-pytest-9.0.3.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..041ba490f3528420585f9b1b5b038e74d2d5cb47
GIT binary patch
literal 10295
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

literal 0
HcmV?d00001

diff --git a/technical-fundamentals/python/coding/problems/tests/lists/__pycache__/test_15_sum_lists.cpython-314-pytest-9.0.3.pyc b/technical-fundamentals/python/coding/problems/tests/lists/__pycache__/test_15_sum_lists.cpython-314-pytest-9.0.3.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..6ac9c13e322ad4904314fd33d600ad6eccb8f42d
GIT binary patch
literal 7508
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
QT=&=U6WsVV0$?`$Ki90(m;e9(

literal 0
HcmV?d00001

diff --git a/technical-fundamentals/python/coding/problems/tests/lists/__pycache__/test_16_sum_lists_forward_order.cpython-314-pytest-9.0.3.pyc b/technical-fundamentals/python/coding/problems/tests/lists/__pycache__/test_16_sum_lists_forward_order.cpython-314-pytest-9.0.3.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..da941ce55b753004d8db93ad13c46424c03a4399
GIT binary patch
literal 14258
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
R<ZYifMdY>zh-j>S`VRmo9q|AF

literal 0
HcmV?d00001

diff --git a/technical-fundamentals/python/coding/problems/tests/lists/__pycache__/test_17_palindrome.cpython-314-pytest-9.0.3.pyc b/technical-fundamentals/python/coding/problems/tests/lists/__pycache__/test_17_palindrome.cpython-314-pytest-9.0.3.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..72a221a74d6f3fa4fae3671cb305cbc460f0209e
GIT binary patch
literal 7034
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
P^lfOXpsXSwwATLuPkRZu

literal 0
HcmV?d00001

diff --git a/technical-fundamentals/python/coding/problems/tests/lists/__pycache__/test_18_intersection.cpython-314-pytest-9.0.3.pyc b/technical-fundamentals/python/coding/problems/tests/lists/__pycache__/test_18_intersection.cpython-314-pytest-9.0.3.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..56f74d86a912c1ee6f63efdef7639ce3e4164bbb
GIT binary patch
literal 8103
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

literal 0
HcmV?d00001

diff --git a/technical-fundamentals/python/coding/problems/tests/lists/__pycache__/test_19_loop_detection.cpython-314-pytest-9.0.3.pyc b/technical-fundamentals/python/coding/problems/tests/lists/__pycache__/test_19_loop_detection.cpython-314-pytest-9.0.3.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..008bed592d64fe68b03582a2b66e8c63848d72c9
GIT binary patch
literal 7661
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

literal 0
HcmV?d00001

diff --git a/technical-fundamentals/python/coding/problems/tests/lists/test_11_remove_dups.py b/technical-fundamentals/python/coding/problems/tests/lists/test_11_remove_dups.py
new file mode 100644
index 00000000..3adc11b3
--- /dev/null
+++ b/technical-fundamentals/python/coding/problems/tests/lists/test_11_remove_dups.py
@@ -0,0 +1,65 @@
+import importlib.util
+from pathlib import Path
+
+_PROBLEMS = Path(__file__).parents[2]
+
+
+def _load(filename):
+    spec = importlib.util.spec_from_file_location(filename, _PROBLEMS / filename)
+    mod = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(mod)
+    return mod
+
+
+_m = _load("11_remove_dups.py")
+remove_dups = _m.remove_dups
+Node = _m.Node
+
+
+def _node(value, next=None):
+    n = Node(value)
+    n.next = next
+    return n
+
+
+def _equal(a, b):
+    while a and b:
+        if a.value != b.value:
+            return False
+        a, b = a.next, b.next
+    return a is None and b is None
+
+
+class TestRemoveDups:
+    def test_removes_duplicates(self):
+        """remove duplicates on linked list"""
+        n1, n2, n3 = Node("a"), Node("a"), Node("b")
+        n1.next, n2.next = n2, n3
+        result = remove_dups(n1)
+        expected = Node("a")
+        expected.next = Node("b")
+        assert _equal(result, expected)
+
+    def test_no_duplicates(self):
+        """no duplicates in linked list"""
+        n1, n2, n3 = Node("a"), Node("b"), Node("c")
+        n1.next, n2.next = n2, n3
+        result = remove_dups(n1)
+        assert _equal(result, n1)
+
+    def test_multiple_duplicates(self):
+        """multiple duplicates in linked list"""
+        n1, n2, n3 = Node("a"), Node("a"), Node("a")
+        n1.next, n2.next = n2, n3
+        result = remove_dups(n1)
+        expected = Node("a")
+        assert _equal(result, expected)
+
+    def test_empty_list(self):
+        """empty linked list"""
+        assert remove_dups() is None
+
+    def test_single_node(self):
+        """linked list with one node"""
+        n = Node("a")
+        assert remove_dups(n) is n
diff --git a/technical-fundamentals/python/coding/problems/tests/lists/test_12_kth_to_last.py b/technical-fundamentals/python/coding/problems/tests/lists/test_12_kth_to_last.py
new file mode 100644
index 00000000..320ea71c
--- /dev/null
+++ b/technical-fundamentals/python/coding/problems/tests/lists/test_12_kth_to_last.py
@@ -0,0 +1,41 @@
+import importlib.util
+from pathlib import Path
+
+_PROBLEMS = Path(__file__).parents[2]
+
+
+def _load(filename):
+    spec = importlib.util.spec_from_file_location(filename, _PROBLEMS / filename)
+    mod = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(mod)
+    return mod
+
+
+_m = _load("12_kth_to_last.py")
+kth_to_last = _m.kth_to_last
+Node = _m.Node
+
+
+class TestKthToLast:
+    def test_returns_none_if_k_is_less_than_1(self):
+        """returns undefined if k is less than 1"""
+        n = Node(1)
+        assert kth_to_last(n, 0) is None
+
+    def test_returns_none_if_k_greater_than_length(self):
+        """returns undefined if k is greater than the length of the list"""
+        n = Node(1)
+        assert kth_to_last(n, 2) is None
+
+    def test_returns_kth_to_last_element(self):
+        """returns the kth to last element when k is valid"""
+        n1, n2, n3, n4, n5 = Node(1), Node(2), Node(3), Node(4), Node(5)
+        n1.next, n2.next, n3.next, n4.next = n2, n3, n4, n5
+        result = kth_to_last(n1, 2)
+        assert result is n4
+
+    def test_returns_head_if_k_equals_length(self):
+        """returns the head if k is equal to the length of the list"""
+        n1, n2, n3, n4, n5 = Node(1), Node(2), Node(3), Node(4), Node(5)
+        n1.next, n2.next, n3.next, n4.next = n2, n3, n4, n5
+        assert kth_to_last(n1, 5) is n1
diff --git a/technical-fundamentals/python/coding/problems/tests/lists/test_13_delete_middle_node.py b/technical-fundamentals/python/coding/problems/tests/lists/test_13_delete_middle_node.py
new file mode 100644
index 00000000..2de617fd
--- /dev/null
+++ b/technical-fundamentals/python/coding/problems/tests/lists/test_13_delete_middle_node.py
@@ -0,0 +1,68 @@
+import importlib.util
+from pathlib import Path
+
+_PROBLEMS = Path(__file__).parents[2]
+
+
+def _load(filename):
+    spec = importlib.util.spec_from_file_location(filename, _PROBLEMS / filename)
+    mod = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(mod)
+    return mod
+
+
+_m = _load("13_delete_middle_node.py")
+delete_middle_node = _m.delete_middle_node
+Node = _m.Node
+
+
+def _values(head):
+    result = []
+    cur = head
+    while cur:
+        result.append(cur.value)
+        cur = cur.next
+    return result
+
+
+class TestDeleteMiddleNode:
+    def test_deletes_middle_node_at_position_1(self):
+        """deletes middle node at position 1"""
+        n0 = Node(0)
+        n0.next = Node(1)
+        n0.next.next = Node(2)
+        n0.next.next.next = Node(3)
+        result = delete_middle_node(n0, 1)
+        assert _values(result) == [0, 2, 3]
+
+    def test_no_deletion_if_position_out_of_range(self):
+        """no deletion if position is out of range"""
+        head = Node(1)
+        head.next = Node(2)
+        head.next.next = Node(3)
+        result = delete_middle_node(head, 4)
+        assert _values(result) == [1, 2, 3]
+
+    def test_no_deletion_if_position_less_than_1(self):
+        """no deletion if position is less than 1"""
+        head = Node(1)
+        head.next = Node(2)
+        head.next.next = Node(3)
+        result = delete_middle_node(head, 0)
+        assert _values(result) == [1, 2, 3]
+
+    def test_no_deletion_if_list_has_only_one_node(self):
+        """no deletion if list has only one node"""
+        head = Node(1)
+        result = delete_middle_node(head, 2)
+        assert result.value == 1
+        assert result.next is None
+
+    def test_no_deletion_if_list_has_only_two_nodes(self):
+        """no deletion if list has only two nodes"""
+        head = Node(1)
+        head.next = Node(2)
+        result = delete_middle_node(head, 2)
+        assert result.value == 1
+        assert result.next.value == 2
+        assert result.next.next is None
diff --git a/technical-fundamentals/python/coding/problems/tests/lists/test_14_partition.py b/technical-fundamentals/python/coding/problems/tests/lists/test_14_partition.py
new file mode 100644
index 00000000..8bbd118a
--- /dev/null
+++ b/technical-fundamentals/python/coding/problems/tests/lists/test_14_partition.py
@@ -0,0 +1,62 @@
+import importlib.util
+from pathlib import Path
+
+_PROBLEMS = Path(__file__).parents[2]
+
+
+def _load(filename):
+    spec = importlib.util.spec_from_file_location(filename, _PROBLEMS / filename)
+    mod = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(mod)
+    return mod
+
+
+_m = _load("14_partition.py")
+partition = _m.partition
+Node = _m.Node
+
+
+def _values(head):
+    result = []
+    cur = head
+    while cur:
+        result.append(cur.value)
+        cur = cur.next
+    return result
+
+
+class TestPartition:
+    def test_partitions_the_list_correctly(self):
+        """partitions the list correctly"""
+        n1, n2, n3, n4, n5, n6, n7 = (
+            Node(3), Node(5), Node(8), Node(5), Node(10), Node(2), Node(1),
+        )
+        n1.next, n2.next, n3.next, n4.next, n5.next, n6.next = n2, n3, n4, n5, n6, n7
+        result = partition(n1, 5)
+        vals = _values(result)
+        left = [v for v in vals if v < 5]
+        right = [v for v in vals if v >= 5]
+        assert len(left) == 3
+        assert len(right) == 4
+        assert vals.index(left[-1]) < vals.index(right[0])
+
+    def test_handles_single_node_list(self):
+        """handles single node list correctly"""
+        n = Node(5)
+        result = partition(n, 5)
+        assert result.value == 5
+        assert result.next is None
+
+    def test_handles_all_nodes_less_than_x(self):
+        """handles all nodes less than x"""
+        n1, n2, n3, n4, n5 = Node(3), Node(2), Node(1), Node(4), Node(5)
+        n1.next, n2.next, n3.next, n4.next = n2, n3, n4, n5
+        result = partition(n1, 6)
+        assert all(v < 6 for v in _values(result))
+
+    def test_handles_all_nodes_greater_than_or_equal_to_x(self):
+        """handles all nodes greater than or equal to x"""
+        n1, n2, n3, n4, n5 = Node(3), Node(2), Node(1), Node(4), Node(5)
+        n1.next, n2.next, n3.next, n4.next = n2, n3, n4, n5
+        result = partition(n1, 0)
+        assert all(v >= 0 for v in _values(result))
diff --git a/technical-fundamentals/python/coding/problems/tests/lists/test_15_sum_lists.py b/technical-fundamentals/python/coding/problems/tests/lists/test_15_sum_lists.py
new file mode 100644
index 00000000..d7a255f8
--- /dev/null
+++ b/technical-fundamentals/python/coding/problems/tests/lists/test_15_sum_lists.py
@@ -0,0 +1,47 @@
+import importlib.util
+from pathlib import Path
+
+_PROBLEMS = Path(__file__).parents[2]
+
+
+def _load(filename):
+    spec = importlib.util.spec_from_file_location(filename, _PROBLEMS / filename)
+    mod = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(mod)
+    return mod
+
+
+_m = _load("15_sum_lists.py")
+sum_lists = _m.sum_lists
+Node = _m.Node
+
+
+def _equal(a, b):
+    while a and b:
+        if a.value != b.value:
+            return False
+        a, b = a.next, b.next
+    return a is None and b is None
+
+
+class TestSumLists:
+    def test_sums_two_lists_without_carryover(self):
+        """sums two non-empty lists without carryover"""
+        list1 = Node(1, Node(2, Node(3)))
+        list2 = Node(4, Node(5, Node(6)))
+        expected = Node(5, Node(7, Node(9)))
+        assert _equal(sum_lists(list1, list2), expected)
+
+    def test_sums_two_lists_with_carryover(self):
+        """sums two non-empty lists with carryover"""
+        list1 = Node(9, Node(9, Node(9)))
+        list2 = Node(1)
+        expected = Node(0, Node(0, Node(0, Node(1))))
+        assert _equal(sum_lists(list1, list2), expected)
+
+    def test_sums_lists_with_different_lengths(self):
+        """sums two lists with different lengths"""
+        list1 = Node(1, Node(2, Node(3, Node(4))))
+        list2 = Node(5, Node(6))
+        expected = Node(6, Node(8, Node(3, Node(4))))
+        assert _equal(sum_lists(list1, list2), expected)
diff --git a/technical-fundamentals/python/coding/problems/tests/lists/test_16_sum_lists_forward_order.py b/technical-fundamentals/python/coding/problems/tests/lists/test_16_sum_lists_forward_order.py
new file mode 100644
index 00000000..83243f83
--- /dev/null
+++ b/technical-fundamentals/python/coding/problems/tests/lists/test_16_sum_lists_forward_order.py
@@ -0,0 +1,68 @@
+import importlib.util
+from pathlib import Path
+
+_PROBLEMS = Path(__file__).parents[2]
+
+
+def _load(filename):
+    spec = importlib.util.spec_from_file_location(filename, _PROBLEMS / filename)
+    mod = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(mod)
+    return mod
+
+
+_m = _load("16_sum_lists_forward_order.py")
+sum_lists_forward_order = _m.sum_lists_forward_order
+Node = _m.Node
+
+
+def _equal(a, b):
+    while a and b:
+        if a.value != b.value:
+            return False
+        a, b = a.next, b.next
+    return a is None and b is None
+
+
+class TestSumListsForwardOrder:
+    def test_sums_one_element_each_without_carryover(self):
+        """Sums one element each without carryover"""
+        assert _equal(sum_lists_forward_order(Node(1), Node(2)), Node(3))
+
+    def test_sums_two_elements_each_without_carryover(self):
+        """Sums two elements each without carryover"""
+        l1 = Node(1, Node(3))
+        l2 = Node(2, Node(3))
+        expected = Node(3, Node(6))
+        assert _equal(sum_lists_forward_order(l1, l2), expected)
+
+    def test_sums_without_carryover(self):
+        """sums two non-empty lists without carryover"""
+        l1 = Node(1, Node(2, Node(3)))
+        l2 = Node(4, Node(5, Node(6)))
+        expected = Node(5, Node(7, Node(9)))
+        assert _equal(sum_lists_forward_order(l1, l2), expected)
+
+    def test_sums_with_carryover(self):
+        """sums two non-empty lists with carryover"""
+        l1 = Node(9, Node(9, Node(9)))
+        l2 = Node(1)
+        expected = Node(1, Node(0, Node(0, Node(0))))
+        assert _equal(sum_lists_forward_order(l1, l2), expected)
+
+    def test_sums_different_lengths(self):
+        """sums two lists with different lengths"""
+        l1 = Node(1, Node(2, Node(3, Node(4))))
+        l2 = Node(5, Node(6))
+        expected = Node(1, Node(2, Node(9, Node(0))))
+        assert _equal(sum_lists_forward_order(l1, l2), expected)
+
+    def test_sums_two_empty_lists(self):
+        """sums two empty lists"""
+        assert sum_lists_forward_order(None, None) is None
+
+    def test_sums_one_empty_and_one_non_empty(self):
+        """sums one empty list and one non-empty list"""
+        l1 = Node(1, Node(2, Node(3)))
+        result = sum_lists_forward_order(l1, None)
+        assert _equal(result, l1)
diff --git a/technical-fundamentals/python/coding/problems/tests/lists/test_17_palindrome.py b/technical-fundamentals/python/coding/problems/tests/lists/test_17_palindrome.py
new file mode 100644
index 00000000..13e44a30
--- /dev/null
+++ b/technical-fundamentals/python/coding/problems/tests/lists/test_17_palindrome.py
@@ -0,0 +1,40 @@
+import importlib.util
+from pathlib import Path
+
+_PROBLEMS = Path(__file__).parents[2]
+
+
+def _load(filename):
+    spec = importlib.util.spec_from_file_location(filename, _PROBLEMS / filename)
+    mod = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(mod)
+    return mod
+
+
+_m = _load("17_palindrome.py")
+is_palindrome = _m.is_palindrome
+Node = _m.Node
+
+
+class TestIsPalindrome:
+    def test_single_node_list_is_palindrome(self):
+        """single node list is palindrome"""
+        assert is_palindrome(Node(1)) == True
+
+    def test_palindrome_list_with_odd_number_of_nodes(self):
+        """palindrome list with odd number of nodes"""
+        n1, n2, n3, n4, n5 = Node(1), Node(2), Node(3), Node(2), Node(1)
+        n1.next, n2.next, n3.next, n4.next = n2, n3, n4, n5
+        assert is_palindrome(n1) == True
+
+    def test_non_palindrome_list(self):
+        """non-palindrome list"""
+        n1, n2, n3, n4, n5 = Node(1), Node(2), Node(3), Node(4), Node(5)
+        n1.next, n2.next, n3.next, n4.next = n2, n3, n4, n5
+        assert is_palindrome(n1) == False
+
+    def test_palindrome_list_with_even_number_of_nodes(self):
+        """palindrome list with even number of nodes"""
+        n1, n2, n3, n4 = Node(1), Node(2), Node(2), Node(1)
+        n1.next, n2.next, n3.next = n2, n3, n4
+        assert is_palindrome(n1) == True
diff --git a/technical-fundamentals/python/coding/problems/tests/lists/test_18_intersection.py b/technical-fundamentals/python/coding/problems/tests/lists/test_18_intersection.py
new file mode 100644
index 00000000..1b3184da
--- /dev/null
+++ b/technical-fundamentals/python/coding/problems/tests/lists/test_18_intersection.py
@@ -0,0 +1,42 @@
+import importlib.util
+from pathlib import Path
+
+_PROBLEMS = Path(__file__).parents[2]
+
+
+def _load(filename):
+    spec = importlib.util.spec_from_file_location(filename, _PROBLEMS / filename)
+    mod = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(mod)
+    return mod
+
+
+_m = _load("18_intersection.py")
+intersection = _m.intersection
+Node = _m.Node
+
+
+class TestIntersection:
+    def test_returns_none_if_lists_do_not_intersect(self):
+        """returns null if the lists do not intersect"""
+        list1 = Node(1, Node(2, Node(3, Node(4))))
+        list2 = Node(5, Node(6, Node(7, Node(8))))
+        assert intersection(list1, list2) is None
+
+    def test_returns_intersection_node(self):
+        """returns intersection node when lists intersect"""
+        common = Node(7, Node(8, Node(9)))
+        list1 = Node(1, Node(2, Node(3, Node(4, common))))
+        list2 = Node(5, Node(6, common))
+        assert intersection(list1, list2) is common
+
+    def test_returns_intersection_at_head(self):
+        """returns intersection node when lists intersect at the head"""
+        common = Node(1, Node(2, Node(3)))
+        assert intersection(common, common) is common
+
+    def test_returns_intersection_at_end(self):
+        """returns intersection node when lists intersect at the end"""
+        list1 = Node(1, Node(2, Node(3, Node(4, Node(5, Node(6, Node(7)))))))
+        list2 = Node(0, list1)
+        assert intersection(list1, list2) is list1
diff --git a/technical-fundamentals/python/coding/problems/tests/lists/test_19_loop_detection.py b/technical-fundamentals/python/coding/problems/tests/lists/test_19_loop_detection.py
new file mode 100644
index 00000000..abf6cb54
--- /dev/null
+++ b/technical-fundamentals/python/coding/problems/tests/lists/test_19_loop_detection.py
@@ -0,0 +1,41 @@
+import importlib.util
+from pathlib import Path
+
+_PROBLEMS = Path(__file__).parents[2]
+
+
+def _load(filename):
+    spec = importlib.util.spec_from_file_location(filename, _PROBLEMS / filename)
+    mod = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(mod)
+    return mod
+
+
+_m = _load("19_loop_detection.py")
+detect_loop = _m.detect_loop
+Node = _m.Node
+
+
+class TestLoopDetection:
+    def test_returns_none_for_single_node(self):
+        """returns null if the list has only one node"""
+        assert detect_loop(Node(1)) is None
+
+    def test_returns_none_for_list_without_loop(self):
+        """returns null if the list does not have a loop"""
+        head = Node(1, Node(2, Node(3, Node(4, Node(5)))))
+        assert detect_loop(head) is None
+
+    def test_returns_node_at_beginning_of_loop(self):
+        """returns the node at the beginning of the loop"""
+        loop_node = Node(31, Node(32))
+        loop_node.next.next = loop_node
+        head = Node(1, Node(2, Node(3, Node(4, Node(5, Node(6, Node(7, Node(8, Node(9, loop_node)))))))))
+        assert detect_loop(head) is loop_node
+
+    def test_returns_node_at_beginning_of_longer_loop(self):
+        """returns the node at the beginning of the loop (longer loop)"""
+        loop_node = Node(11, Node(12, Node(13)))
+        loop_node.next.next.next = loop_node
+        head = Node(1, Node(2, Node(3, Node(4, Node(5, Node(6, Node(7, Node(8, Node(9, Node(10, loop_node))))))))))
+        assert detect_loop(head) is loop_node
diff --git a/technical-fundamentals/python/coding/problems/tests/recursion/__init__.py b/technical-fundamentals/python/coding/problems/tests/recursion/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/technical-fundamentals/python/coding/problems/tests/recursion/__pycache__/__init__.cpython-314.pyc b/technical-fundamentals/python/coding/problems/tests/recursion/__pycache__/__init__.cpython-314.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..1e766e94c87d5269917d7aa537cd6885a5f0c119
GIT binary patch
literal 216
zcmXwzL23d)5JkHcg9zpX?y?GDEZvJo2olJ8==79M=}h-f)ve4f+Z-iVa+@1u$Ufbm
ze^K>{Uwr<{<9w!)z7~I!_fH;o=^G3W2|m@EdQ#8&^;_{M-9t975#9w^pf!Qc0z39c
zv_W9KTAhGgKt2;*3Pw})5YX0+tZ9mUbd_n*1=9$0eW<+y>nm~x=-7WW*h>1A6vSvF
j3njlS$x$fFW!GP)o7Pvc!7Wcxi`-K({EoHOJWliv2Q)k*

literal 0
HcmV?d00001

diff --git a/technical-fundamentals/python/coding/problems/tests/recursion/__pycache__/test_41_triple_steps.cpython-314-pytest-9.0.3.pyc b/technical-fundamentals/python/coding/problems/tests/recursion/__pycache__/test_41_triple_steps.cpython-314-pytest-9.0.3.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..8fff9106b756897fdae9e7964a82c00ce3a089fd
GIT binary patch
literal 7537
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
A`2YX_

literal 0
HcmV?d00001

diff --git a/technical-fundamentals/python/coding/problems/tests/recursion/__pycache__/test_42_robot_in_a_grid.cpython-314-pytest-9.0.3.pyc b/technical-fundamentals/python/coding/problems/tests/recursion/__pycache__/test_42_robot_in_a_grid.cpython-314-pytest-9.0.3.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..9f3617b576d8ae8f840e63e8b80fd779bc68b98a
GIT binary patch
literal 5059
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
GXzah$FV<ZE

literal 0
HcmV?d00001

diff --git a/technical-fundamentals/python/coding/problems/tests/recursion/__pycache__/test_43_magic_index.cpython-314-pytest-9.0.3.pyc b/technical-fundamentals/python/coding/problems/tests/recursion/__pycache__/test_43_magic_index.cpython-314-pytest-9.0.3.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..88fe51d3a67bf8cbe741be7de427e455cd510006
GIT binary patch
literal 5086
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%0AG3qLHH9P
zKO-G-@Q>v1pCbo8J^b^f-N<A+GWpBw=aJW%!N2)MA@)_2_`|L6v5s%N>3J}AY<KK*
nd+c<Jj6O(A?k48iiMbXz`Vb^9311P!hfz^j7WRPdt=Yc;1{~|-

literal 0
HcmV?d00001

diff --git a/technical-fundamentals/python/coding/problems/tests/recursion/__pycache__/test_44_power_set.cpython-314-pytest-9.0.3.pyc b/technical-fundamentals/python/coding/problems/tests/recursion/__pycache__/test_44_power_set.cpython-314-pytest-9.0.3.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..5be061828dda2c909b07bdb4e5aceacfe1e4ddf0
GIT binary patch
literal 7076
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

literal 0
HcmV?d00001

diff --git a/technical-fundamentals/python/coding/problems/tests/recursion/__pycache__/test_45_recursive_multiply.cpython-314-pytest-9.0.3.pyc b/technical-fundamentals/python/coding/problems/tests/recursion/__pycache__/test_45_recursive_multiply.cpython-314-pytest-9.0.3.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..1ee731687b9ace373029ab05955e4e0b74c83adf
GIT binary patch
literal 5587
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

literal 0
HcmV?d00001

diff --git a/technical-fundamentals/python/coding/problems/tests/recursion/__pycache__/test_46_towers_of_hanoi.cpython-314-pytest-9.0.3.pyc b/technical-fundamentals/python/coding/problems/tests/recursion/__pycache__/test_46_towers_of_hanoi.cpython-314-pytest-9.0.3.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..17f8cc9760c96cfb3a5557b7bf4cf9f1afa5e5df
GIT binary patch
literal 4022
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
Sd$<~T;q`E5HVFW0vVQ?$5)oMd

literal 0
HcmV?d00001

diff --git a/technical-fundamentals/python/coding/problems/tests/recursion/__pycache__/test_47_permutations_with_dups.cpython-314-pytest-9.0.3.pyc b/technical-fundamentals/python/coding/problems/tests/recursion/__pycache__/test_47_permutations_with_dups.cpython-314-pytest-9.0.3.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..56cdf6f133a410e85b3d7cdc4b90d06ac19ba557
GIT binary patch
literal 5159
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
BUzPv>

literal 0
HcmV?d00001

diff --git a/technical-fundamentals/python/coding/problems/tests/recursion/__pycache__/test_48_coin_change.cpython-314-pytest-9.0.3.pyc b/technical-fundamentals/python/coding/problems/tests/recursion/__pycache__/test_48_coin_change.cpython-314-pytest-9.0.3.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..7a1d6a35b683b340588e9ce53b1b06a43c75da89
GIT binary patch
literal 5846
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
Y;-k{=ednIjDSVm93m5hg5PqqD0bOtY)c^nh

literal 0
HcmV?d00001

diff --git a/technical-fundamentals/python/coding/problems/tests/recursion/test_41_triple_steps.py b/technical-fundamentals/python/coding/problems/tests/recursion/test_41_triple_steps.py
new file mode 100644
index 00000000..ce0fa4c2
--- /dev/null
+++ b/technical-fundamentals/python/coding/problems/tests/recursion/test_41_triple_steps.py
@@ -0,0 +1,31 @@
+import importlib.util
+from pathlib import Path
+
+_PROBLEMS = Path(__file__).parents[2]
+
+
+def _load(filename):
+    spec = importlib.util.spec_from_file_location(filename, _PROBLEMS / filename)
+    mod = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(mod)
+    return mod
+
+
+_m = _load("41_triple_steps.py")
+triple_step = _m.triple_step
+
+
+class TestTripleStep:
+    def test_returns_correct_count_for_valid_input(self):
+        """returns correct count for valid input"""
+        assert triple_step(0) == 0
+        assert triple_step(1) == 1
+        assert triple_step(2) == 2
+        assert triple_step(3) == 4
+        assert triple_step(4) == 7
+        assert triple_step(5) == 13
+
+    def test_returns_0_for_negative_input(self):
+        """returns 0 for negative input"""
+        assert triple_step(-1) == 0
+        assert triple_step(-10) == 0
diff --git a/technical-fundamentals/python/coding/problems/tests/recursion/test_42_robot_in_a_grid.py b/technical-fundamentals/python/coding/problems/tests/recursion/test_42_robot_in_a_grid.py
new file mode 100644
index 00000000..6070e53e
--- /dev/null
+++ b/technical-fundamentals/python/coding/problems/tests/recursion/test_42_robot_in_a_grid.py
@@ -0,0 +1,46 @@
+import importlib.util
+from pathlib import Path
+
+_PROBLEMS = Path(__file__).parents[2]
+
+
+def _load(filename):
+    spec = importlib.util.spec_from_file_location(filename, _PROBLEMS / filename)
+    mod = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(mod)
+    return mod
+
+
+_m = _load("42_robot_in_a_grid.py")
+robot_in_a_grid = _m.robot_in_a_grid
+
+
+class TestRobotInAGrid:
+    def test_returns_correct_path_for_3x3_grid(self):
+        """returns correct path for a 3x3 grid"""
+        grid = [
+            [True, True, False],
+            [True, False, True],
+            [True, True, True],
+        ]
+        assert robot_in_a_grid(grid) == [(0, 0), (0, 1), (0, 2), (1, 2), (2, 2)]
+
+    def test_returns_correct_path_for_4x4_grid(self):
+        """returns correct path for a 4x4 grid"""
+        grid = [
+            [True, True, True, False],
+            [True, False, True, True],
+            [True, True, False, False],
+            [False, True, True, True],
+        ]
+        assert robot_in_a_grid(grid) == [(0, 0), (0, 1), (0, 2), (1, 2), (1, 3), (2, 3), (3, 3)]
+
+    def test_returns_false_for_no_path(self):
+        """returns false for no path"""
+        grid = [
+            [True, False, True, False],
+            [False, False, True, True],
+            [True, True, True, False],
+            [True, True, True, True],
+        ]
+        assert not robot_in_a_grid(grid)
diff --git a/technical-fundamentals/python/coding/problems/tests/recursion/test_43_magic_index.py b/technical-fundamentals/python/coding/problems/tests/recursion/test_43_magic_index.py
new file mode 100644
index 00000000..b45db069
--- /dev/null
+++ b/technical-fundamentals/python/coding/problems/tests/recursion/test_43_magic_index.py
@@ -0,0 +1,30 @@
+import importlib.util
+from pathlib import Path
+
+_PROBLEMS = Path(__file__).parents[2]
+
+
+def _load(filename):
+    spec = importlib.util.spec_from_file_location(filename, _PROBLEMS / filename)
+    mod = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(mod)
+    return mod
+
+
+_m = _load("43_magic_index.py")
+find_magic_index_distinct = _m.find_magic_index_distinct
+find_magic_index_non_distinct = _m.find_magic_index_non_distinct
+
+
+class TestMagicIndexDistinct:
+    def test_returns_correct_magic_index(self):
+        """returns correct magic index for distinct input"""
+        assert find_magic_index_distinct([-2, -1, 0, 2, 4, 6, 8]) == 4
+        assert not find_magic_index_distinct([-3, -2, -1, 4, 5, 7, 9])
+
+
+class TestMagicIndexNonDistinct:
+    def test_returns_correct_magic_index(self):
+        """returns correct magic index for non-distinct input"""
+        assert find_magic_index_non_distinct([-10, -5, 2, 2, 2, 2, 4, 7, 9, 12, 13]) == 2
+        assert not find_magic_index_non_distinct([-10, -5, 0, 2, 5, 7, 9, 12, 13])
diff --git a/technical-fundamentals/python/coding/problems/tests/recursion/test_44_power_set.py b/technical-fundamentals/python/coding/problems/tests/recursion/test_44_power_set.py
new file mode 100644
index 00000000..60c8a1a9
--- /dev/null
+++ b/technical-fundamentals/python/coding/problems/tests/recursion/test_44_power_set.py
@@ -0,0 +1,39 @@
+import importlib.util
+from pathlib import Path
+
+_PROBLEMS = Path(__file__).parents[2]
+
+
+def _load(filename):
+    spec = importlib.util.spec_from_file_location(filename, _PROBLEMS / filename)
+    mod = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(mod)
+    return mod
+
+
+_m = _load("44_power_set.py")
+power_set = _m.power_set
+
+
+def _sorted_sets(sets):
+    return sorted([sorted(s) for s in sets])
+
+
+class TestPowerSet:
+    def test_returns_correct_power_set_for_3_elements(self):
+        """returns correct power set for a given set"""
+        expected = [[], [1], [1, 2], [1, 2, 3], [1, 3], [2], [2, 3], [3]]
+        assert _sorted_sets(power_set([1, 2, 3])) == _sorted_sets(expected)
+
+    def test_returns_correct_power_set_for_empty_set(self):
+        """returns correct power set for 4"""
+        assert _sorted_sets(power_set([])) == [[]]
+
+    def test_returns_correct_power_set_for_4_elements(self):
+        expected = [
+            [], [1], [2], [3], [4],
+            [1, 2], [1, 3], [1, 4], [2, 3], [2, 4], [3, 4],
+            [1, 2, 3], [1, 2, 4], [1, 3, 4], [2, 3, 4],
+            [1, 2, 3, 4],
+        ]
+        assert _sorted_sets(power_set([1, 2, 3, 4])) == _sorted_sets(expected)
diff --git a/technical-fundamentals/python/coding/problems/tests/recursion/test_45_recursive_multiply.py b/technical-fundamentals/python/coding/problems/tests/recursion/test_45_recursive_multiply.py
new file mode 100644
index 00000000..83da7ba5
--- /dev/null
+++ b/technical-fundamentals/python/coding/problems/tests/recursion/test_45_recursive_multiply.py
@@ -0,0 +1,25 @@
+import importlib.util
+from pathlib import Path
+
+_PROBLEMS = Path(__file__).parents[2]
+
+
+def _load(filename):
+    spec = importlib.util.spec_from_file_location(filename, _PROBLEMS / filename)
+    mod = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(mod)
+    return mod
+
+
+_m = _load("45_recursive_multiply.py")
+recursive_multiply = _m.recursive_multiply
+
+
+class TestRecursiveMultiply:
+    def test_returns_correct_product(self):
+        """returns correct product for two positive integers"""
+        assert recursive_multiply(3, 4) == 12
+        assert recursive_multiply(5, 7) == 35
+        assert recursive_multiply(9, 2) == 18
+        assert recursive_multiply(0, 10) == 0
+        assert recursive_multiply(8, 0) == 0
diff --git a/technical-fundamentals/python/coding/problems/tests/recursion/test_46_towers_of_hanoi.py b/technical-fundamentals/python/coding/problems/tests/recursion/test_46_towers_of_hanoi.py
new file mode 100644
index 00000000..069c08bf
--- /dev/null
+++ b/technical-fundamentals/python/coding/problems/tests/recursion/test_46_towers_of_hanoi.py
@@ -0,0 +1,23 @@
+import importlib.util
+from pathlib import Path
+
+_PROBLEMS = Path(__file__).parents[2]
+
+
+def _load(filename):
+    spec = importlib.util.spec_from_file_location(filename, _PROBLEMS / filename)
+    mod = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(mod)
+    return mod
+
+
+_m = _load("46_towers_of_hanoi.py")
+towers_of_hanoi = _m.towers_of_hanoi
+
+
+class TestTowersOfHanoi:
+    def test_returns_correct_tower_configuration(self):
+        """returns correct tower configuration after moving disks"""
+        assert towers_of_hanoi(3) == ([], [], [3, 2, 1])
+        assert towers_of_hanoi(4) == ([], [], [4, 3, 2, 1])
+        assert towers_of_hanoi(5) == ([], [], [5, 4, 3, 2, 1])
diff --git a/technical-fundamentals/python/coding/problems/tests/recursion/test_47_permutations_with_dups.py b/technical-fundamentals/python/coding/problems/tests/recursion/test_47_permutations_with_dups.py
new file mode 100644
index 00000000..634f6485
--- /dev/null
+++ b/technical-fundamentals/python/coding/problems/tests/recursion/test_47_permutations_with_dups.py
@@ -0,0 +1,37 @@
+import importlib.util
+from pathlib import Path
+
+_PROBLEMS = Path(__file__).parents[2]
+
+
+def _load(filename):
+    spec = importlib.util.spec_from_file_location(filename, _PROBLEMS / filename)
+    mod = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(mod)
+    return mod
+
+
+_m = _load("47_permutations_with_dups.py")
+permutations_without_dups = _m.permutations_without_dups
+permutations_with_dups = _m.permutations_with_dups
+
+
+class TestPermutationsWithoutDups:
+    def test_returns_correct_permutations(self):
+        """returns correct permutations for a string of unique characters"""
+        result = permutations_without_dups("abc")
+        expected = ["abc", "acb", "bac", "bca", "cab", "cba"]
+        assert all(p in result for p in expected)
+
+
+class TestPermutationsWithDups:
+    def test_returns_correct_permutations_with_dups(self):
+        """returns correct permutations for a string with duplicate characters"""
+        result = permutations_with_dups("aab")
+        expected = ["aab", "aba", "baa"]
+        assert all(p in result for p in expected)
+
+    def test_returns_correct_permutations_4_chars(self):
+        result = permutations_with_dups("aabb")
+        expected = ["aabb", "abab", "abba", "baab", "baba", "bbaa"]
+        assert all(p in result for p in expected)
diff --git a/technical-fundamentals/python/coding/problems/tests/recursion/test_48_coin_change.py b/technical-fundamentals/python/coding/problems/tests/recursion/test_48_coin_change.py
new file mode 100644
index 00000000..c5108e3c
--- /dev/null
+++ b/technical-fundamentals/python/coding/problems/tests/recursion/test_48_coin_change.py
@@ -0,0 +1,28 @@
+import importlib.util
+from pathlib import Path
+
+_PROBLEMS = Path(__file__).parents[2]
+
+
+def _load(filename):
+    spec = importlib.util.spec_from_file_location(filename, _PROBLEMS / filename)
+    mod = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(mod)
+    return mod
+
+
+_m = _load("48_coin_change.py")
+coin_change = _m.coin_change
+
+
+class TestCoinChange:
+    def test_returns_0_if_coins_do_not_match(self):
+        """returns 0 if coins are invalid or do not match"""
+        assert coin_change(10, [15]) == 0
+        assert coin_change(10, []) == 0
+        assert coin_change(10, [7]) == 0
+
+    def test_returns_correct_counts(self):
+        """returns correct counts for various examples"""
+        assert coin_change(5, [1, 2, 5]) == 4
+        assert coin_change(10, [10]) == 1
diff --git a/technical-fundamentals/python/coding/problems/tests/stacks/__init__.py b/technical-fundamentals/python/coding/problems/tests/stacks/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/technical-fundamentals/python/coding/problems/tests/stacks/__pycache__/__init__.cpython-314.pyc b/technical-fundamentals/python/coding/problems/tests/stacks/__pycache__/__init__.cpython-314.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..100bccc9e116a92c10ef291927f739e61bad5b4d
GIT binary patch
literal 213
zcmXwzF$w}P5JeM35kXI2XC<Pey?6u>!Fq|=QKP%bG82{UY(0us+SVJm*qea<;?EoY
zF#K`9*A+pJ!N<h;iuRZMLER2;7aK7YBe{ACYJ|OxVMVZIB!*mhb7feQJE8Ur^V#eS
z#(Jcy!P|sTr6qXOM{BgoCi{y`RgTuHjG-v~(OJ+gHTD1nxm|`ihieXx*eiWzND^a>
dPm*a-R-Hxe(o2R*YK021Bu98RrIgeR^aVBEI?n(A

literal 0
HcmV?d00001

diff --git a/technical-fundamentals/python/coding/problems/tests/stacks/__pycache__/test_21_three_stacks.cpython-314-pytest-9.0.3.pyc b/technical-fundamentals/python/coding/problems/tests/stacks/__pycache__/test_21_three_stacks.cpython-314-pytest-9.0.3.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..7ac9e88c506274100cc2518a81baf6340d8c3098
GIT binary patch
literal 18237
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

literal 0
HcmV?d00001

diff --git a/technical-fundamentals/python/coding/problems/tests/stacks/__pycache__/test_22_stack_min.cpython-314-pytest-9.0.3.pyc b/technical-fundamentals/python/coding/problems/tests/stacks/__pycache__/test_22_stack_min.cpython-314-pytest-9.0.3.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..6dbe2ae7a8c4aeb7a79ffea7fcd1d4a7d27e2a29
GIT binary patch
literal 19252
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
S%<*ad%ZR{@tP%k1QU3)lR%P!1

literal 0
HcmV?d00001

diff --git a/technical-fundamentals/python/coding/problems/tests/stacks/__pycache__/test_23_stack_of_plates.cpython-314-pytest-9.0.3.pyc b/technical-fundamentals/python/coding/problems/tests/stacks/__pycache__/test_23_stack_of_plates.cpython-314-pytest-9.0.3.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..a20d856705a18a500fdd549d9649d2d9b7ff4347
GIT binary patch
literal 14650
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
NgTq4K76QQw`wzWYTk8M-

literal 0
HcmV?d00001

diff --git a/technical-fundamentals/python/coding/problems/tests/stacks/__pycache__/test_24_queue_via_stacks.cpython-314-pytest-9.0.3.pyc b/technical-fundamentals/python/coding/problems/tests/stacks/__pycache__/test_24_queue_via_stacks.cpython-314-pytest-9.0.3.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..eb1731c029bb66c067115a8c3e008cd122f6c4b7
GIT binary patch
literal 14750
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
Zd!B@&llvz2jR!vu#MwQ|3=rDYe*q2M2G9Ti

literal 0
HcmV?d00001

diff --git a/technical-fundamentals/python/coding/problems/tests/stacks/__pycache__/test_25_sort_stack.cpython-314-pytest-9.0.3.pyc b/technical-fundamentals/python/coding/problems/tests/stacks/__pycache__/test_25_sort_stack.cpython-314-pytest-9.0.3.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..28f666667f66b2eff1c68077e11e36b535562e54
GIT binary patch
literal 14076
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

literal 0
HcmV?d00001

diff --git a/technical-fundamentals/python/coding/problems/tests/stacks/__pycache__/test_26_animal_shelter.cpython-314-pytest-9.0.3.pyc b/technical-fundamentals/python/coding/problems/tests/stacks/__pycache__/test_26_animal_shelter.cpython-314-pytest-9.0.3.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..39d77c7a04ee47a71d71e85e57392599a6b861c4
GIT binary patch
literal 8150
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
T+3Hu?eP5&p__2Ks2yN`&0yK?0

literal 0
HcmV?d00001

diff --git a/technical-fundamentals/python/coding/problems/tests/stacks/test_21_three_stacks.py b/technical-fundamentals/python/coding/problems/tests/stacks/test_21_three_stacks.py
new file mode 100644
index 00000000..baff603f
--- /dev/null
+++ b/technical-fundamentals/python/coding/problems/tests/stacks/test_21_three_stacks.py
@@ -0,0 +1,66 @@
+import importlib.util
+from pathlib import Path
+
+_PROBLEMS = Path(__file__).parents[2]
+
+
+def _load(filename):
+    spec = importlib.util.spec_from_file_location(filename, _PROBLEMS / filename)
+    mod = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(mod)
+    return mod
+
+
+_m = _load("21_three_stacks.py")
+ThreeStacks = _m.ThreeStacks
+
+
+class TestThreeStacks:
+    def test_push_and_pop_from_stack_0(self):
+        """push and pop elements from stack 1"""
+        s = ThreeStacks(9)
+        s.push(0, 1); s.push(0, 2); s.push(0, 3)
+        assert s.pop(0) == 3
+        assert s.pop(0) == 2
+        assert s.pop(0) == 1
+        assert s.pop(0) is None
+
+    def test_push_and_pop_from_stack_1(self):
+        """push and pop elements from stack 2"""
+        s = ThreeStacks(9)
+        s.push(1, 4); s.push(1, 5); s.push(1, 6)
+        assert s.pop(1) == 6
+        assert s.pop(1) == 5
+        assert s.pop(1) == 4
+        assert s.pop(1) is None
+
+    def test_push_and_pop_from_stack_2(self):
+        """push and pop elements from stack 3"""
+        s = ThreeStacks(9)
+        s.push(2, 7); s.push(2, 8); s.push(2, 9)
+        assert s.pop(2) == 9
+        assert s.pop(2) == 8
+        assert s.pop(2) == 7
+        assert s.pop(2) is None
+
+    def test_pop_from_empty_stack_returns_none(self):
+        """pop elements from empty stack"""
+        s = ThreeStacks(3)
+        assert s.pop(0) is None
+        assert s.pop(1) is None
+        assert s.pop(2) is None
+
+    def test_peek_elements_from_stacks(self):
+        """peek elements from stacks"""
+        s = ThreeStacks(3)
+        s.push(0, 1); s.push(1, 2); s.push(2, 3)
+        assert s.peek(0) == 1
+        assert s.peek(1) == 2
+        assert s.peek(2) == 3
+
+    def test_peek_from_empty_stack_returns_none(self):
+        """peek elements from empty stack"""
+        s = ThreeStacks(3)
+        assert s.peek(0) is None
+        assert s.peek(1) is None
+        assert s.peek(2) is None
diff --git a/technical-fundamentals/python/coding/problems/tests/stacks/test_22_stack_min.py b/technical-fundamentals/python/coding/problems/tests/stacks/test_22_stack_min.py
new file mode 100644
index 00000000..c2934ab3
--- /dev/null
+++ b/technical-fundamentals/python/coding/problems/tests/stacks/test_22_stack_min.py
@@ -0,0 +1,50 @@
+import importlib.util
+from pathlib import Path
+
+_PROBLEMS = Path(__file__).parents[2]
+
+
+def _load(filename):
+    spec = importlib.util.spec_from_file_location(filename, _PROBLEMS / filename)
+    mod = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(mod)
+    return mod
+
+
+_m = _load("22_stack_min.py")
+StackMin = _m.StackMin
+
+
+class TestStackMin:
+    def test_push_pop_and_min(self):
+        """push and pop elements from stack"""
+        s = StackMin()
+        s.push(5); s.push(2); s.push(8); s.push(1)
+        assert s.min() == 1
+        assert s.pop() == 1
+        assert s.min() == 2
+        assert s.pop() == 8
+        assert s.min() == 2
+        assert s.pop() == 2
+        assert s.min() == 5
+        assert s.pop() == 5
+        assert s.min() is None
+
+    def test_min_returns_none_when_empty(self):
+        """min method returns undefined when stack is empty"""
+        s = StackMin()
+        assert s.min() is None
+
+    def test_push_pop_mixed_with_min(self):
+        """push and pop mixed with min operations"""
+        s = StackMin()
+        s.push(3); assert s.min() == 3
+        s.push(5); assert s.min() == 3
+        s.push(2); assert s.min() == 2
+        s.push(1); assert s.min() == 1
+        assert s.pop() == 1; assert s.min() == 2
+        assert s.pop() == 2; assert s.min() == 3
+        s.push(0); assert s.min() == 0
+        assert s.pop() == 0; assert s.min() == 3
+        assert s.pop() == 5; assert s.min() == 3
+        assert s.pop() == 3; assert s.min() is None
diff --git a/technical-fundamentals/python/coding/problems/tests/stacks/test_23_stack_of_plates.py b/technical-fundamentals/python/coding/problems/tests/stacks/test_23_stack_of_plates.py
new file mode 100644
index 00000000..a0da1284
--- /dev/null
+++ b/technical-fundamentals/python/coding/problems/tests/stacks/test_23_stack_of_plates.py
@@ -0,0 +1,54 @@
+import importlib.util
+from pathlib import Path
+
+_PROBLEMS = Path(__file__).parents[2]
+
+
+def _load(filename):
+    spec = importlib.util.spec_from_file_location(filename, _PROBLEMS / filename)
+    mod = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(mod)
+    return mod
+
+
+_m = _load("23_stack_of_plates.py")
+StackOfPlates = _m.StackOfPlates
+
+
+class TestStackOfPlates:
+    def test_push_and_pop(self):
+        """push and pop elements from stack"""
+        s = StackOfPlates(3)
+        s.push(1); s.push(2); s.push(3)
+        assert s.pop() == 3
+        assert s.pop() == 2
+        assert s.pop() == 1
+        assert s.pop() is None
+        s.push(4); s.push(5); s.push(6)
+        assert s.pop() == 6
+        assert s.pop() == 5
+        assert s.pop() == 4
+        assert s.pop() is None
+
+    def test_push_and_pop_across_multiple_stacks(self):
+        """push and pop elements from multiple stacks"""
+        s = StackOfPlates(2)
+        s.push(1); s.push(2); s.push(3); s.push(4); s.push(5)
+        assert s.pop() == 5
+        assert s.pop() == 4
+        assert s.pop() == 3
+        assert s.pop() == 2
+        assert s.pop() == 1
+        assert s.pop() is None
+
+    def test_pop_from_empty_returns_none(self):
+        """pop from empty stack returns undefined"""
+        s = StackOfPlates(2)
+        assert s.pop() is None
+
+    def test_push_beyond_capacity_creates_new_stack(self):
+        """push beyond capacity creates new stack"""
+        s = StackOfPlates(2)
+        s.push(1); s.push(2); s.push(3); s.push(4)
+        assert s.pop() == 4
+        assert s.pop() == 3
diff --git a/technical-fundamentals/python/coding/problems/tests/stacks/test_24_queue_via_stacks.py b/technical-fundamentals/python/coding/problems/tests/stacks/test_24_queue_via_stacks.py
new file mode 100644
index 00000000..1c1f8899
--- /dev/null
+++ b/technical-fundamentals/python/coding/problems/tests/stacks/test_24_queue_via_stacks.py
@@ -0,0 +1,50 @@
+import importlib.util
+from pathlib import Path
+
+_PROBLEMS = Path(__file__).parents[2]
+
+
+def _load(filename):
+    spec = importlib.util.spec_from_file_location(filename, _PROBLEMS / filename)
+    mod = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(mod)
+    return mod
+
+
+_m = _load("24_queue_via_stacks.py")
+MyQueue = _m.MyQueue
+
+
+class TestMyQueue:
+    def test_enqueue_and_dequeue(self):
+        """enqueue and dequeue elements from queue"""
+        q = MyQueue()
+        q.enqueue(1); q.enqueue(2); q.enqueue(3)
+        assert q.dequeue() == 1
+        assert q.dequeue() == 2
+        assert q.dequeue() == 3
+        assert q.dequeue() is None
+
+    def test_enqueue_dequeue_mixed_with_peek(self):
+        """enqueue and dequeue mixed with peek operations"""
+        q = MyQueue()
+        q.enqueue(1); assert q.peek() == 1
+        q.enqueue(2); assert q.peek() == 1
+        assert q.dequeue() == 1; assert q.peek() == 2
+        q.enqueue(3); assert q.peek() == 2
+        assert q.dequeue() == 2; assert q.peek() == 3
+        assert q.dequeue() == 3; assert q.peek() is None
+
+    def test_peek_from_empty_returns_none(self):
+        """peek from empty queue returns undefined"""
+        assert MyQueue().peek() is None
+
+    def test_is_empty_returns_true_for_empty_queue(self):
+        """isEmpty returns true for empty queue"""
+        assert MyQueue().is_empty() == True
+
+    def test_is_empty_returns_false_for_non_empty_queue(self):
+        """isEmpty returns false for non-empty queue"""
+        q = MyQueue()
+        q.enqueue(1)
+        assert q.is_empty() == False
diff --git a/technical-fundamentals/python/coding/problems/tests/stacks/test_25_sort_stack.py b/technical-fundamentals/python/coding/problems/tests/stacks/test_25_sort_stack.py
new file mode 100644
index 00000000..75bd081f
--- /dev/null
+++ b/technical-fundamentals/python/coding/problems/tests/stacks/test_25_sort_stack.py
@@ -0,0 +1,54 @@
+import importlib.util
+from pathlib import Path
+
+_PROBLEMS = Path(__file__).parents[2]
+
+
+def _load(filename):
+    spec = importlib.util.spec_from_file_location(filename, _PROBLEMS / filename)
+    mod = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(mod)
+    return mod
+
+
+_m = _load("25_sort_stack.py")
+SortStack = _m.SortStack
+
+
+class TestSortStack:
+    def test_push_elements_in_sorted_order(self):
+        """push elements in sorted order"""
+        s = SortStack()
+        s.push(3); assert s.peek() == 3
+        s.push(1); assert s.peek() == 1
+        s.push(5); assert s.peek() == 1
+        s.push(2); assert s.peek() == 1
+        s.push(4); assert s.peek() == 1
+
+    def test_pop_elements_in_sorted_order(self):
+        """pop elements in sorted order"""
+        s = SortStack()
+        s.push(3); s.push(1); s.push(5); s.push(2); s.push(4)
+        assert s.pop() == 1
+        assert s.pop() == 2
+        assert s.pop() == 3
+        assert s.pop() == 4
+        assert s.pop() == 5
+        assert s.pop() is None
+
+    def test_peek_does_not_remove_element(self):
+        """peek returns the top element without removing it"""
+        s = SortStack()
+        s.push(3); s.push(1); s.push(5)
+        assert s.peek() == 1
+        assert s.peek() == 1
+
+    def test_is_empty_returns_true_for_empty_stack(self):
+        """isEmpty returns true for empty stack"""
+        assert SortStack().is_empty() == True
+
+    def test_is_empty_returns_false_for_non_empty(self):
+        """isEmpty returns false for non-empty stack"""
+        s = SortStack()
+        s.push(1)
+        assert s.is_empty() == False
diff --git a/technical-fundamentals/python/coding/problems/tests/stacks/test_26_animal_shelter.py b/technical-fundamentals/python/coding/problems/tests/stacks/test_26_animal_shelter.py
new file mode 100644
index 00000000..29ee17b6
--- /dev/null
+++ b/technical-fundamentals/python/coding/problems/tests/stacks/test_26_animal_shelter.py
@@ -0,0 +1,35 @@
+import importlib.util
+from pathlib import Path
+
+_PROBLEMS = Path(__file__).parents[2]
+
+
+def _load(filename):
+    spec = importlib.util.spec_from_file_location(filename, _PROBLEMS / filename)
+    mod = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(mod)
+    return mod
+
+
+_m = _load("26_animal_shelter.py")
+AnimalShelter = _m.AnimalShelter
+
+
+class TestAnimalShelter:
+    def test_enqueue_and_dequeue(self):
+        """enqueue and dequeue elements from queue"""
+        shelter = AnimalShelter()
+        shelter.enqueue("dog"); shelter.enqueue("cat"); shelter.enqueue("dog")
+        assert shelter.dequeue_any().type == "dog"
+        assert shelter.dequeue_any().type == "cat"
+        shelter.enqueue("cat"); shelter.enqueue("dog")
+        assert shelter.dequeue_dog().type == "dog"
+        shelter.enqueue("dog")
+        assert shelter.dequeue_cat().type == "cat"
+
+    def test_dequeue_returns_none_when_empty(self):
+        """dequeue methods return undefined when shelter is empty"""
+        shelter = AnimalShelter()
+        assert shelter.dequeue_any() is None
+        assert shelter.dequeue_dog() is None
+        assert shelter.dequeue_cat() is None
diff --git a/technical-fundamentals/python/coding/problems/tests/strings/__init__.py b/technical-fundamentals/python/coding/problems/tests/strings/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/technical-fundamentals/python/coding/problems/tests/strings/__pycache__/__init__.cpython-314.pyc b/technical-fundamentals/python/coding/problems/tests/strings/__pycache__/__init__.cpython-314.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..6f970d58aff2a870e2b538f7a22e0806ccc7721d
GIT binary patch
literal 214
zcmXwzK?=e^3`J)wiU@iLU5RMwUOa+`;JS=$w4?1zNv4(VypC6L>kV|}&Kc0ZNM4dp
z__NV)AiQ||(V;&>`Ah!b-Sco0J24Scxw#AK`1u`<4~9J>F_g;bhG9$gjHzQ-#_<KT
zaY&8E>zq(!EjUbbqf=GPkG08EiN>jdp=w=j4Wu^H<^&blLxClGH~UBI$Zr{vL>ujr
bWKp$`{;ITDUErF!K0`>!0bY@mk|IxEbk{pY

literal 0
HcmV?d00001

diff --git a/technical-fundamentals/python/coding/problems/tests/strings/__pycache__/test_01_is_unique.cpython-314-pytest-9.0.3.pyc b/technical-fundamentals/python/coding/problems/tests/strings/__pycache__/test_01_is_unique.cpython-314-pytest-9.0.3.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..33dcdf0f9a7118d26c59bb175e9d25f5e08f7ed4
GIT binary patch
literal 14455
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

literal 0
HcmV?d00001

diff --git a/technical-fundamentals/python/coding/problems/tests/strings/__pycache__/test_02_check_permutations.cpython-314-pytest-9.0.3.pyc b/technical-fundamentals/python/coding/problems/tests/strings/__pycache__/test_02_check_permutations.cpython-314-pytest-9.0.3.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..eb1ac78922cc2e09585db57bb22814c59d537a3b
GIT binary patch
literal 9819
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

literal 0
HcmV?d00001

diff --git a/technical-fundamentals/python/coding/problems/tests/strings/__pycache__/test_03_urlify.cpython-314-pytest-9.0.3.pyc b/technical-fundamentals/python/coding/problems/tests/strings/__pycache__/test_03_urlify.cpython-314-pytest-9.0.3.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..9d024b6385584cf61892cd12dd129e782f6b4612
GIT binary patch
literal 7977
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
YJWXXD9eQx6k@z-oM3`77K)jm%112VVE&u=k

literal 0
HcmV?d00001

diff --git a/technical-fundamentals/python/coding/problems/tests/strings/__pycache__/test_04_palindrome_permutation.cpython-314-pytest-9.0.3.pyc b/technical-fundamentals/python/coding/problems/tests/strings/__pycache__/test_04_palindrome_permutation.cpython-314-pytest-9.0.3.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..2e7311371c94be623aa5478ff3e2443e684beb7e
GIT binary patch
literal 10854
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
Wy}3qju1-#W7rD&c+$KO+ZvO*GnRhJ!

literal 0
HcmV?d00001

diff --git a/technical-fundamentals/python/coding/problems/tests/strings/__pycache__/test_05_one_away.cpython-314-pytest-9.0.3.pyc b/technical-fundamentals/python/coding/problems/tests/strings/__pycache__/test_05_one_away.cpython-314-pytest-9.0.3.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..1eb8aac6d535e191409843cb751be467149b1fe7
GIT binary patch
literal 12014
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

literal 0
HcmV?d00001

diff --git a/technical-fundamentals/python/coding/problems/tests/strings/__pycache__/test_06_string_compression.cpython-314-pytest-9.0.3.pyc b/technical-fundamentals/python/coding/problems/tests/strings/__pycache__/test_06_string_compression.cpython-314-pytest-9.0.3.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..d6fa2c0b1158abb638cda69aff666cc9c5ae16a1
GIT binary patch
literal 7574
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
T>lmz}_OC;o+>HYSg!T4c4PMFs

literal 0
HcmV?d00001

diff --git a/technical-fundamentals/python/coding/problems/tests/strings/__pycache__/test_07_rotate_matrix.cpython-314-pytest-9.0.3.pyc b/technical-fundamentals/python/coding/problems/tests/strings/__pycache__/test_07_rotate_matrix.cpython-314-pytest-9.0.3.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b3a57b018aa542618724e66287edbec15134f91f
GIT binary patch
literal 5603
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

literal 0
HcmV?d00001

diff --git a/technical-fundamentals/python/coding/problems/tests/strings/__pycache__/test_08_zero_matrix.cpython-314-pytest-9.0.3.pyc b/technical-fundamentals/python/coding/problems/tests/strings/__pycache__/test_08_zero_matrix.cpython-314-pytest-9.0.3.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..7ac483ddb120ac925faeb309af9e3489f9fc620d
GIT binary patch
literal 5257
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
ZRONf|j+^Bh<!W?0^0K6F5ip{u{{nT4(`Enw

literal 0
HcmV?d00001

diff --git a/technical-fundamentals/python/coding/problems/tests/strings/__pycache__/test_09_string_rotation.cpython-314-pytest-9.0.3.pyc b/technical-fundamentals/python/coding/problems/tests/strings/__pycache__/test_09_string_rotation.cpython-314-pytest-9.0.3.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..a4558568b93ce1e783859399bf0cbe3c1fa96942
GIT binary patch
literal 4140
zcmeGfOKcm*b#}QVmw)*q+o{u%l5AI-D5NOKsSQVloz$@8L@KjU>5J^aid;!-m)!Nt
z(vDmNV2c8A&_i;}QAhh`^prynIrb<<j%f@Wv_1BgT8Dg2c{BSFNej@mhYZNK@4b2N
z&Ac}=@6EiP%_I>tI{rf=A3><biJ&PyviBJv9dsM%(jsyt@s$@MZ8?t?6gQgpdSY%I
zdgMiQA>k(S=vHD3-Ac|$o{h?h!07(>wmkKVeacPik(0>H+{%n0T?zEu>?i^{dJ^fe
zIoXqTbGkHvwD^BHxvWV{sTl5N%^yj~L;->~Xm1BV2dxSw2NmB&$lyFKJ=CgbH5Ra{
zXet%p2nDlnq(iJG_H_cRDg}Nya#gB`$OnDiw~`s8IaQSdtvul1xwNdsS)$Q&Y~ost
zHKw%PhQ&@&$E@LXVmI-6!!ogD*9^B|w^#yK^xwVx-nFF<*htf^x1mo+ad{TAY@==x
zmNGvCZLeF4FqNBV8BLQZLM#G3lt=Vjp}_u9`aLxXEj7XZU0SLT`wwQ#rKR%p^dC!&
zmTQu`4fEa`#5C$#CD*KNwi-3VdSkuas)NOrYgn}8Y`L3ut5mb=jn+oVA@-VOHYrF`
zFhpGfT#v%j7qLfUV!OhlqO--K;Ga<^Ihax${&WFA2R%<6|Mc=FmwTylH&uQ-`H#ha
zs$aiV*-gFQ`R()Mu}_Pi6njano75hj*-e%@?>tk~kKg_CyFKM}S2_LpJ5Q9tvsAWo
zV-IYh`y)K6;ap(MfwK|pw!ImUHDKsla58k{%D0cWkrT*<vjV$W(Pe;9v9n{k;>N4U
zRrM&WVT>JJ0bf55p6b411ACZ98~*CvIv@jknD-2|IiJp>)o?fKDA+fS1iLNV&-<!X
z)Cz5hGbP_2JuuwMn!;jO1cZ&kx>DNMXyFFMw7upnj#vqn8(Jw%hW%q&>rBQ?%8%Z;
z0?ERMrK#z*9o#fw7t~q)<xmv+1&)FW{WSnsVKv)R&vex@Pt<eIGe>uhy|$Zq{ek=}
zKi12ayZQ11<*E8A83EaWVDfzeuBP|y!Yn$diYmYuZjPi&j;zaf%46u}M0n5@J#uHI
z8odBp?9Mu$1#j1+4LIPhqSY{=R1~kLA42NNR%5f0p1XN%R-W@EbVZNur<aP_ui@ci
zC|J;oz}WcZ&`1X)jxq2lSngns^^-$->4Qev*ISbGs2=O{=wSIUiRtk}Wy92^tB1-)
zg8A!-LuJDPp(hWOjRtm0v8ld8;KcQmp037A(g0Uo<$Fc6KFfSV4K;|k8dwg#o06Wn
zBsmiNW%x(nuUwLdsb}EGkK7*-8O)>wqu?DB7F{qc%VtrVe^*$<*_tM>YKUVq9L#a>
zCI=Uo;%t@6Kjz@{nZzxeodj}Lqk=uV{7Cvyo}Ygt-N(G+f<}{n@{z*4kevxwfcUIw
zjTVPaZ1ST?t~RI9DWUbIMz!Qeg?Z0LxvbGg3BrpxOJ0E-4k-*9gdM?<;4Mr{ht%w*
zV-S<2p&PHY8<yK>QC?<1g0fSXZrW|DE=2K$Wv>|)7Ih|psj+Ty3oLt8cnG!Y8X-1e
z$MCvMpx9vZL&q{&q6WY$M4VE57%w7a)<?|t6X*Mh-*{8=b*B5fE_z+wXyus!YL4=P
z4&~2lUK$$}0q|E98-Af;lLzFp10}f&^zQ&V=-;_xz1&1MH?gD6Z(j%S@Fswr+{E_v
z-Q0OVzc?;HH#gr?{ofNVa6TkM<bfNaU#ar}^;DSidO&mgdWb%}8KR**koe+wXl4ij
zt3T&hST=-y&antC=+*z99D5?nu`S!(G)a(YQ}+zGn6BBbYngD{^)X<skYB+%iflsi
z94l}z#=$rT6C9l3;4FY;a*m^u9B3Ty``<yS;q>5v_a+l0h~l9MVnF^hALFGovADgo
zqb@$42f)+B(r)f5pkJ;C(9JFORR8yc3tSD!5aEfz7x_wE45+8VoYw=I+e;z(7}5@x
z@3#l|mn$CoWe8S9n$RRsGM2RjQ?W?*7_%hypBsRuF}~9_EM5qJ%3*lH5DIUbmf5l~
zCa>^7U*g~j05*ytj!*?^*l^+gyw-+LgW3^{YZj#SdZXsnpqye1Z^KL<6V&*%{ffxl
zgkLHJI06XeA^!ej$ipw>NOa~!QjT8!PL-oKq;C<2!VMv<jW9JRYh((v*elp8ghj8U
zK-nr1^B!rqCQF1Y7WaANHLjBlUvEWzt0w$r$l?yXW8pzZ_??nRO1$GR=M#7~QNmw3
z;-XECbBufN2zgTzw`%n*?*Vt2=+MP|rEdfHHX=#VzYzK>+C`(^pi}=zk9>COZ_B;(
qcsD)1UH&?Kwv%`fQ>5JgvM8C`$&KwM#yhd^Vrl7yw1+qpWBdfso@b!|

literal 0
HcmV?d00001

diff --git a/technical-fundamentals/python/coding/problems/tests/strings/test_01_is_unique.py b/technical-fundamentals/python/coding/problems/tests/strings/test_01_is_unique.py
new file mode 100644
index 00000000..11963154
--- /dev/null
+++ b/technical-fundamentals/python/coding/problems/tests/strings/test_01_is_unique.py
@@ -0,0 +1,52 @@
+import importlib.util
+from pathlib import Path
+
+_PROBLEMS = Path(__file__).parents[2]
+
+
+def _load(filename):
+    spec = importlib.util.spec_from_file_location(filename, _PROBLEMS / filename)
+    mod = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(mod)
+    return mod
+
+
+_m = _load("01_is_unique.py")
+is_unique = _m.is_unique
+
+
+class TestIsUnique:
+    def test_returns_true_for_unique_characters(self):
+        """Returns true for unique characters"""
+        assert is_unique("abc") == True
+        assert is_unique("abcdefg") == True
+        assert is_unique("123456") == True
+        assert is_unique("!@#$%^") == True
+
+    def test_returns_false_for_non_unique_characters(self):
+        """Returns false for non-unique characters"""
+        assert is_unique("aab") == False
+        assert is_unique("hello") == False
+        assert is_unique("testing") == False
+        assert is_unique("1234456") == False
+        assert is_unique("abccdef") == False
+
+    def test_returns_true_for_empty_string(self):
+        """Returns true for empty string"""
+        assert is_unique("") == True
+
+    def test_handles_whitespace_correctly(self):
+        """Handles whitespace correctly"""
+        assert is_unique("a b c") == False
+        assert is_unique("ab c") == True
+
+    def test_handles_special_characters_correctly(self):
+        """Handles special characters correctly"""
+        assert is_unique("!@#$%^&*") == True
+        assert is_unique("!@#$%^&*!") == False
+
+    def test_handles_mixed_case_correctly(self):
+        """Handles mixed case correctly"""
+        assert is_unique("aA") == True
+        assert is_unique("Aa") == True
+        assert is_unique("Hello") == False
diff --git a/technical-fundamentals/python/coding/problems/tests/strings/test_02_check_permutations.py b/technical-fundamentals/python/coding/problems/tests/strings/test_02_check_permutations.py
new file mode 100644
index 00000000..79a60bb9
--- /dev/null
+++ b/technical-fundamentals/python/coding/problems/tests/strings/test_02_check_permutations.py
@@ -0,0 +1,45 @@
+import importlib.util
+from pathlib import Path
+
+_PROBLEMS = Path(__file__).parents[2]
+
+
+def _load(filename):
+    spec = importlib.util.spec_from_file_location(filename, _PROBLEMS / filename)
+    mod = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(mod)
+    return mod
+
+
+_m = _load("02_check_permutations.py")
+check_permutations = _m.check_permutations
+
+
+class TestCheckPermutations:
+    def test_returns_true_for_permutations_with_same_length_strings(self):
+        """Returns true for permutations with same length strings"""
+        assert check_permutations("abc", "cba") == True
+
+    def test_returns_false_for_strings_with_different_lengths(self):
+        """Returns false for strings with different lengths"""
+        assert check_permutations("abc", "cbad") == False
+
+    def test_returns_true_for_permutations_with_special_characters(self):
+        """Returns true for permutations with special characters"""
+        assert check_permutations("abc!", "!bac") == True
+
+    def test_returns_false_for_non_permutations_with_special_characters(self):
+        """Returns false for non-permutations with special characters"""
+        assert check_permutations("abc!", "!bcd") == False
+
+    def test_returns_true_for_empty_strings(self):
+        """Returns true for empty strings"""
+        assert check_permutations("", "") == True
+
+    def test_returns_true_for_long_strings_with_same_characters(self):
+        """Returns true for long strings with same characters"""
+        assert check_permutations("a" * 1000, "a" * 1000) == True
+
+    def test_returns_false_for_long_strings_with_different_characters(self):
+        """Returns false for long strings with different characters"""
+        assert check_permutations("a" * 1000, "b" * 1000) == False
diff --git a/technical-fundamentals/python/coding/problems/tests/strings/test_03_urlify.py b/technical-fundamentals/python/coding/problems/tests/strings/test_03_urlify.py
new file mode 100644
index 00000000..e1d8fd18
--- /dev/null
+++ b/technical-fundamentals/python/coding/problems/tests/strings/test_03_urlify.py
@@ -0,0 +1,45 @@
+import importlib.util
+from pathlib import Path
+
+_PROBLEMS = Path(__file__).parents[2]
+
+
+def _load(filename):
+    spec = importlib.util.spec_from_file_location(filename, _PROBLEMS / filename)
+    mod = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(mod)
+    return mod
+
+
+_m = _load("03_urlify.py")
+urlify = _m.urlify
+
+
+class TestURLify:
+    def test_replaces_spaces_with_percent_20(self):
+        """Replaces spaces in a string with '%20'"""
+        assert urlify("ab c") == "ab%20c"
+
+    def test_handles_leading_and_trailing_spaces(self):
+        """Handles leading and trailing spaces"""
+        assert urlify("  ab c  ") == "%20%20ab%20c%20%20"
+
+    def test_returns_empty_string_when_input_is_empty(self):
+        """Returns empty string when input is empty"""
+        assert urlify("") == ""
+
+    def test_does_not_modify_string_without_spaces(self):
+        """Doesn't modify string without spaces"""
+        assert urlify("abc") == "abc"
+
+    def test_handles_multiple_consecutive_spaces(self):
+        """Handles multiple consecutive spaces"""
+        assert urlify("a  b   c") == "a%20%20b%20%20%20c"
+
+    def test_handles_special_characters(self):
+        """Handles special characters"""
+        assert urlify("a b!c") == "a%20b!c"
+
+    def test_mr_john_smith(self):
+        """Mr 3ohn Smith"""
+        assert urlify("Mr 3ohn Smith") == "Mr%203ohn%20Smith"
diff --git a/technical-fundamentals/python/coding/problems/tests/strings/test_04_palindrome_permutation.py b/technical-fundamentals/python/coding/problems/tests/strings/test_04_palindrome_permutation.py
new file mode 100644
index 00000000..19fa29e8
--- /dev/null
+++ b/technical-fundamentals/python/coding/problems/tests/strings/test_04_palindrome_permutation.py
@@ -0,0 +1,57 @@
+import importlib.util
+from pathlib import Path
+
+_PROBLEMS = Path(__file__).parents[2]
+
+
+def _load(filename):
+    spec = importlib.util.spec_from_file_location(filename, _PROBLEMS / filename)
+    mod = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(mod)
+    return mod
+
+
+_m = _load("04_palindrome_permutation.py")
+palindrome_permutation = _m.palindrome_permutation
+
+
+class TestPalindromePermutation:
+    def test_empty_string(self):
+        """Empty string"""
+        assert palindrome_permutation("") == True
+
+    def test_single_character_string(self):
+        """Single character string"""
+        assert palindrome_permutation("a") == True
+
+    def test_palindrome_with_odd_length(self):
+        """Palindrome with odd length"""
+        assert palindrome_permutation("taco cat") == True
+
+    def test_palindrome_with_even_length(self):
+        """Palindrome with even length"""
+        assert palindrome_permutation("rdeder") == True
+
+    def test_non_palindrome_with_odd_length(self):
+        """Non-palindrome with odd length"""
+        assert palindrome_permutation("hello") == False
+
+    def test_non_palindrome_with_even_length(self):
+        """Non-palindrome with even length"""
+        assert palindrome_permutation("world") == False
+
+    def test_string_with_mixed_case(self):
+        """String with mixed case"""
+        assert palindrome_permutation("RaceCar") == True
+
+    def test_string_with_repeated_letters(self):
+        """String with repeated letters"""
+        assert palindrome_permutation("rrracecrrar") == True
+
+    def test_string_with_non_alphanumeric_characters(self):
+        """String with non-alphanumeric characters"""
+        assert palindrome_permutation("12321") == True
+
+    def test_string_with_no_possible_palindrome_permutation(self):
+        """String with no possible palindrome permutation"""
+        assert palindrome_permutation("abcdefg") == False
diff --git a/technical-fundamentals/python/coding/problems/tests/strings/test_05_one_away.py b/technical-fundamentals/python/coding/problems/tests/strings/test_05_one_away.py
new file mode 100644
index 00000000..e27e1b4c
--- /dev/null
+++ b/technical-fundamentals/python/coding/problems/tests/strings/test_05_one_away.py
@@ -0,0 +1,58 @@
+import importlib.util
+from pathlib import Path
+
+_PROBLEMS = Path(__file__).parents[2]
+
+
+def _load(filename):
+    spec = importlib.util.spec_from_file_location(filename, _PROBLEMS / filename)
+    mod = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(mod)
+    return mod
+
+
+_m = _load("05_one_away.py")
+is_one_away = _m.is_one_away
+
+
+class TestOneAway:
+    def test_one_away_replace(self):
+        """One Away - Replace"""
+        assert is_one_away("pale", "bale") == True
+        assert is_one_away("bbaa", "bcca") == False
+
+    def test_one_away_replace2(self):
+        """One Away - Replace"""
+        assert is_one_away("pale", "bale") == True
+
+    def test_one_away_insert(self):
+        """One Away - Insert"""
+        assert is_one_away("pale", "ple") == True
+
+    def test_one_away_remove(self):
+        """One Away - Remove"""
+        assert is_one_away("pale", "pales") == True
+
+    def test_same_strings(self):
+        """Same Strings"""
+        assert is_one_away("abc", "abc") == True
+
+    def test_more_than_one_edit_away(self):
+        """More Than One Edit Away"""
+        assert is_one_away("abcd", "efgh") == False
+
+    def test_more_than_one_edit_away_2(self):
+        """More Than One Edit Away #2"""
+        assert is_one_away("palesa", "pale") == False
+
+    def test_empty_strings(self):
+        """Empty Strings"""
+        assert is_one_away("", "") == True
+
+    def test_one_character_difference(self):
+        """One Character Difference"""
+        assert is_one_away("a", "ab") == True
+
+    def test_empty_and_non_empty_string(self):
+        """Empty and Non-Empty String"""
+        assert is_one_away("", "a") == True
diff --git a/technical-fundamentals/python/coding/problems/tests/strings/test_06_string_compression.py b/technical-fundamentals/python/coding/problems/tests/strings/test_06_string_compression.py
new file mode 100644
index 00000000..9653b6a7
--- /dev/null
+++ b/technical-fundamentals/python/coding/problems/tests/strings/test_06_string_compression.py
@@ -0,0 +1,41 @@
+import importlib.util
+from pathlib import Path
+
+_PROBLEMS = Path(__file__).parents[2]
+
+
+def _load(filename):
+    spec = importlib.util.spec_from_file_location(filename, _PROBLEMS / filename)
+    mod = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(mod)
+    return mod
+
+
+_m = _load("06_string_compression.py")
+string_compression = _m.string_compression
+
+
+class TestStringCompression:
+    def test_compresses_string_with_repeated_characters(self):
+        """compresses string with repeated characters"""
+        assert string_compression("aabcccccaaa") == "a2b1c5a3"
+
+    def test_returns_original_string_if_compression_does_not_reduce_length(self):
+        """returns original string if compression does not reduce length"""
+        assert string_compression("abcde") == "abcde"
+
+    def test_returns_empty_string_for_empty_input(self):
+        """returns empty string for empty input"""
+        assert string_compression("") == ""
+
+    def test_returns_single_character_for_single_character_string(self):
+        """returns single character for string with single character"""
+        assert string_compression("a") == "a"
+
+    def test_compresses_uppercase_and_lowercase(self):
+        """compresses string with uppercase and lowercase letters"""
+        assert string_compression("AAAbbbCCCddd") == "A3b3C3d3"
+
+    def test_returns_original_string_if_no_repeated_characters(self):
+        """returns original string if no repeated characters"""
+        assert string_compression("abcdef") == "abcdef"
diff --git a/technical-fundamentals/python/coding/problems/tests/strings/test_07_rotate_matrix.py b/technical-fundamentals/python/coding/problems/tests/strings/test_07_rotate_matrix.py
new file mode 100644
index 00000000..6b6d9c6d
--- /dev/null
+++ b/technical-fundamentals/python/coding/problems/tests/strings/test_07_rotate_matrix.py
@@ -0,0 +1,63 @@
+import importlib.util
+from pathlib import Path
+
+_PROBLEMS = Path(__file__).parents[2]
+
+
+def _load(filename):
+    spec = importlib.util.spec_from_file_location(filename, _PROBLEMS / filename)
+    mod = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(mod)
+    return mod
+
+
+_m = _load("07_rotate_matrix.py")
+rotate_matrix = _m.rotate_matrix
+
+
+class TestRotateMatrix:
+    def test_rotates_2x2_matrix_clockwise(self):
+        """rotates 2x2 matrix clockwise"""
+        matrix = [[1, 2], [3, 4]]
+        rotate_matrix(matrix)
+        assert matrix == [[3, 1], [4, 2]]
+
+    def test_rotates_3x3_matrix_clockwise(self):
+        """rotates 3x3 matrix clockwise"""
+        matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
+        rotate_matrix(matrix)
+        assert matrix == [[7, 4, 1], [8, 5, 2], [9, 6, 3]]
+
+    def test_rotates_4x4_matrix_clockwise(self):
+        """rotates 4x4 matrix clockwise"""
+        matrix = [
+            [1, 2, 3, 4],
+            [5, 6, 7, 8],
+            [9, 10, 11, 12],
+            [13, 14, 15, 16],
+        ]
+        rotate_matrix(matrix)
+        assert matrix == [
+            [13, 9, 5, 1],
+            [14, 10, 6, 2],
+            [15, 11, 7, 3],
+            [16, 12, 8, 4],
+        ]
+
+    def test_rotates_5x5_matrix_clockwise(self):
+        """rotates 5x5 matrix clockwise"""
+        matrix = [
+            [1, 2, 3, 4, 5],
+            [6, 7, 8, 9, 10],
+            [11, 12, 13, 14, 15],
+            [16, 17, 18, 19, 20],
+            [21, 22, 23, 24, 25],
+        ]
+        rotate_matrix(matrix)
+        assert matrix == [
+            [21, 16, 11, 6, 1],
+            [22, 17, 12, 7, 2],
+            [23, 18, 13, 8, 3],
+            [24, 19, 14, 9, 4],
+            [25, 20, 15, 10, 5],
+        ]
diff --git a/technical-fundamentals/python/coding/problems/tests/strings/test_08_zero_matrix.py b/technical-fundamentals/python/coding/problems/tests/strings/test_08_zero_matrix.py
new file mode 100644
index 00000000..62794143
--- /dev/null
+++ b/technical-fundamentals/python/coding/problems/tests/strings/test_08_zero_matrix.py
@@ -0,0 +1,61 @@
+import importlib.util
+from pathlib import Path
+
+_PROBLEMS = Path(__file__).parents[2]
+
+
+def _load(filename):
+    spec = importlib.util.spec_from_file_location(filename, _PROBLEMS / filename)
+    mod = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(mod)
+    return mod
+
+
+_m = _load("08_zero_matrix.py")
+zero_matrix = _m.zero_matrix
+
+
+class TestZeroMatrix:
+    def test_zeroes_2x2_matrix(self):
+        """zeroes 2x2 matrix"""
+        matrix = [[0, 2], [3, 4]]
+        zero_matrix(matrix)
+        assert matrix == [[0, 0], [0, 4]]
+
+    def test_zeroes_3x3_matrix(self):
+        """zeroes 3x3 matrix"""
+        matrix = [[1, 2, 3], [4, 5, 6], [7, 0, 9]]
+        zero_matrix(matrix)
+        assert matrix == [[1, 0, 3], [4, 0, 6], [0, 0, 0]]
+
+    def test_zeroes_4x4_matrix(self):
+        """zeroes 4x4 matrix"""
+        matrix = [
+            [1, 2, 3, 4],
+            [5, 6, 0, 8],
+            [9, 10, 11, 12],
+            [13, 14, 15, 16],
+        ]
+        zero_matrix(matrix)
+        assert matrix == [
+            [1, 2, 0, 4],
+            [0, 0, 0, 0],
+            [9, 10, 0, 12],
+            [13, 14, 0, 16],
+        ]
+
+    def test_2_zeroes_4x4_matrix(self):
+        """2 zeroes 4x4 matrix"""
+        matrix = [
+            [0, 2, 3, 4],
+            [5, 6, 0, 8],
+            [9, 10, 11, 12],
+            [13, 14, 15, 16],
+        ]
+        zero_matrix(matrix)
+        assert matrix == [
+            [0, 0, 0, 0],
+            [0, 0, 0, 0],
+            [0, 10, 0, 12],
+            [0, 14, 0, 16],
+        ]
diff --git a/technical-fundamentals/python/coding/problems/tests/strings/test_09_string_rotation.py b/technical-fundamentals/python/coding/problems/tests/strings/test_09_string_rotation.py
new file mode 100644
index 00000000..08546dc1
--- /dev/null
+++ b/technical-fundamentals/python/coding/problems/tests/strings/test_09_string_rotation.py
@@ -0,0 +1,29 @@
+import importlib.util
+from pathlib import Path
+
+_PROBLEMS = Path(__file__).parents[2]
+
+
+def _load(filename):
+    spec = importlib.util.spec_from_file_location(filename, _PROBLEMS / filename)
+    mod = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(mod)
+    return mod
+
+
+_utils = _load("utils/strings.py")
+
+
+class TestStringRotation:
+    def setup_method(self):
+        _utils.reassign_is_substring()
+        _m = _load("09_string_rotation.py")
+        self.string_rotation = _m.string_rotation
+
+    def test_rotates_a_string(self):
+        """rotates a string"""
+        assert self.string_rotation("Hello", "oHell") == True
+
+    def test_rotates_another_string(self):
+        """rotates another string"""
+        assert self.string_rotation("waterbottle", "erbottlewat") == True
diff --git a/technical-fundamentals/python/coding/problems/tests/trees/__init__.py b/technical-fundamentals/python/coding/problems/tests/trees/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/technical-fundamentals/python/coding/problems/tests/trees/__pycache__/__init__.cpython-314.pyc b/technical-fundamentals/python/coding/problems/tests/trees/__pycache__/__init__.cpython-314.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..af304c85c7c3c9d0e12e735d4a0a90bde13f1976
GIT binary patch
literal 212
zcmXwzK@I^y5JkHQ5eX--vl5}$izA3gtS4=zm}aJXRP~I^&el;}$<_^sz3zm+`1LBk
zQu*V4uPeN6gO3jL8SF3lgLm7*RcypijO6MrsNwf_2p?zIG7>|soURzwWRDm-hWTuE
z0&N^prSUQ$R7njE<J9O_Ws`kr5|yKIDq|>Wms$g{O|&^cL3Wp6&i<PHBS(k~QKXG_
cQ8X>;M`w}Sq|9(hE#Dw?<N&Xxl#-gBzVhNaXaE2J

literal 0
HcmV?d00001

diff --git a/technical-fundamentals/python/coding/problems/tests/trees/__pycache__/test_30_trees.cpython-314-pytest-9.0.3.pyc b/technical-fundamentals/python/coding/problems/tests/trees/__pycache__/test_30_trees.cpython-314-pytest-9.0.3.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..1bbc0fcdf7dc3662510b3530e383b7b5160ad5ec
GIT binary patch
literal 3927
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

literal 0
HcmV?d00001

diff --git a/technical-fundamentals/python/coding/problems/tests/trees/__pycache__/test_31_has_route_between_nodes.cpython-314-pytest-9.0.3.pyc b/technical-fundamentals/python/coding/problems/tests/trees/__pycache__/test_31_has_route_between_nodes.cpython-314-pytest-9.0.3.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..d93f8b6749f7fc730fb4e5ff042ba171d551f14e
GIT binary patch
literal 9672
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
ZYTt~+?q9igr560u-^Pt?At3a!{{j5k&e;F}

literal 0
HcmV?d00001

diff --git a/technical-fundamentals/python/coding/problems/tests/trees/__pycache__/test_32_minimal_tree.cpython-314-pytest-9.0.3.pyc b/technical-fundamentals/python/coding/problems/tests/trees/__pycache__/test_32_minimal_tree.cpython-314-pytest-9.0.3.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b11d689bfccf870d46d0d0a7d167e96d4338d4b7
GIT binary patch
literal 7622
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

literal 0
HcmV?d00001

diff --git a/technical-fundamentals/python/coding/problems/tests/trees/__pycache__/test_33_list_of_depths.cpython-314-pytest-9.0.3.pyc b/technical-fundamentals/python/coding/problems/tests/trees/__pycache__/test_33_list_of_depths.cpython-314-pytest-9.0.3.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..073432239bc69f39f5710f1b586bb378a3854e4b
GIT binary patch
literal 8095
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

literal 0
HcmV?d00001

diff --git a/technical-fundamentals/python/coding/problems/tests/trees/__pycache__/test_34_check_balanced.cpython-314-pytest-9.0.3.pyc b/technical-fundamentals/python/coding/problems/tests/trees/__pycache__/test_34_check_balanced.cpython-314-pytest-9.0.3.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..198d7226cc209bf4830bfdec90fe77687eb7d370
GIT binary patch
literal 5214
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

literal 0
HcmV?d00001

diff --git a/technical-fundamentals/python/coding/problems/tests/trees/__pycache__/test_35_validate_bst.cpython-314-pytest-9.0.3.pyc b/technical-fundamentals/python/coding/problems/tests/trees/__pycache__/test_35_validate_bst.cpython-314-pytest-9.0.3.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..0997dd5976d21b8e9580cbbf967883568b825d72
GIT binary patch
literal 7633
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
J4S`^7{ug^vW>x?I

literal 0
HcmV?d00001

diff --git a/technical-fundamentals/python/coding/problems/tests/trees/__pycache__/test_36_successor.cpython-314-pytest-9.0.3.pyc b/technical-fundamentals/python/coding/problems/tests/trees/__pycache__/test_36_successor.cpython-314-pytest-9.0.3.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..6feb9373514dd297d10731582d4532ae28e57b28
GIT binary patch
literal 9972
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
Cr6St^

literal 0
HcmV?d00001

diff --git a/technical-fundamentals/python/coding/problems/tests/trees/__pycache__/test_37_build_order.cpython-314-pytest-9.0.3.pyc b/technical-fundamentals/python/coding/problems/tests/trees/__pycache__/test_37_build_order.cpython-314-pytest-9.0.3.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c63508727dfa92f5a229ea18c5c6a500ff4cc070
GIT binary patch
literal 5798
zcmdT|U2GHC6}~eb+vA_u2__4>z{VlVZf42am;?x7q5Ntggy0U4eMuNO_9SuFvCW+^
zkkCr5RB4xXC3uWhRh7r^#$#3O1AW_<N(o^Jx~1yRTOTTI$pbBY={a|PJTYdyR9jV@
z#AnVq_uO;uow?^bXYSruN0`9%yTm_>yZnUYQE)EFW;X5vQzuu6Dx4#x!0+N&Urp>G
zXC>3$W3>d#Ahd|*<g+0&Wb49acrw&WCL=?F<tw}0ao)IJ6$jpGNM?uX+eXaTWUQB{
zlGD$OPsX#!hLyvao!tcN{M(2c7!ob5*`*47L<#;C#W6)-QZ{GK=It498(1mv!Ea*)
zNS#b@C6cV|!&RUTt(&fKG7)f8<76P>@Ps(Cs0wYoh8lewZd`EITNTHJEPpdjn|052
zY?e_P7oA=`z{ARgF(t@C#kp#Qnx*0tlWJzM#I_k#J+DpE%A7V`Ea_UQlFymNN|}YU
zta|a}=$Q+bSm#`&P=hvZh4w5^s^khfWfA=*^tPH6ACu8VIX9;>iJSSL#lR=}ZZgS!
zoW5e{)JV^P|LaCNODjLp^QMu`?A!NAx>z=KdcCOM_<-uU!hG7)^Rwk*K3Do+x>hcL
z$Fi9#8R_c0Ia?{G^OZueJd>`{%2Y|8Gr-yaM<&&Ei`NDZX;Zagsi0LTOfyxTXMR{&
zu0Z2385w@YSs-=tG_v*1vD?SiBbn7m=6?T|=f0A^{xG{1`C<L^({SQW>UL^9tgMEW
z<#*P?>H4WBlKkoUpPpZrcC1P}7Ee8rl20PB`p5?OA`4wF4Z108oQ<|I48}PadlG_1
zC8l^aVfx-66$m5P;F2l=_4CahP$l4ls^65yi5XG@xP4jdGA#BaF76_(ZPNzEZ2*ru
zx^Wt4our7`by27as-Q|KQT3}LP|@ZE;3d_U5>x)FIN{8We7wcosy^ty<)U!y)VMSZ
zkL%i%_i&wXoe^d}A!H|+aKj=iSuI`)0hk!~4+`qmkB0`uA=^R?sKG{%Wbs`zUA<(;
z)*OcWOmEXjEw+EJCsdtH@65HZqp5$iX*dvD^}isfK~+{muQk_QO=Gp3Ya^W9Ic{s}
z*K&@HelWL?8df9!g}J$)@tSjU`@!5IYSgncTCc_DyeGAzt*s09Y5#x=uY^<sYD|rf
z2hzeOZEyl(oL?T#osO<??<M0wXBN(VR!}>S2vy$^fnHWSA>O(d_EO!f(Xx@uS11L*
zN^)RHa$reLS7`Eju2d`}i{)y~WI~P!Q%uM+p}>S`=Bv){V-XJ$p(ev*04|PwDDG!c
zL9ZIf4k0<T5X%_=lxA{Ie|7$_!dniHDFM0_=1#kjynzHZ4Pk;#F?T}iZqy;~u|pGX
zd{1~G9zCiE3y0C^kYa>y*-Y{%A7`Ip^rI%D7z13fUon*MPm)Ki=0l2cFGMjPv+!{M
zVSpelM_HE!2wl>sUZwfUTs22^7KLVxy=Jj&V4eUAgKgK0*-8!Y7)`aAQe`Sv(s-f>
zX+~~ZM>UI`;OmCubB59iWeE))FJuc%zgaEi$~-M8GNcy0G);Hn(%!}iMQ}vxkqvr<
zgI?i)C0GuJtyx+^W}kr|1R087G=@Hte1-O#*X%d%O(`tB8HQ8sI^fGQ{syE@{*uUi
zCO_%gdN+SJym)D;Z*gQfv7BEH-@o+hzWXB&5)bkZ!YlFfpGi;SZ!He5#ou3%M<1p}
zfv%)RSL37Wvi<)EH1YRc(Pcir<+2auQIF)R!PnxjD}j+ma@An8blH`_$dMj<#>F|L
z8dGx3fq^E9aknW&1wp}6)K~mjK#B={#}ozj*43&S0|<9h5T=+zc4|5zXhKb_`7}4F
z^pFXh1HT%{u7?2F!`~3h4KI}YNRsR&4iL_O$DO1I)$J~5#Xqz-;@d@vf)ZZnF=uJz
zhLO~9>vCKuS8QnDP~nM6H+p%vF6<a{486#r-z-8+17)foA|O9IrubWWz^GRw7O-NH
z1!%5l=mra&xtZ6iSjX|8ReUrBhK-<ciZW}rzhiA)-c{oZz{u0e6^&z?RYbADmOK92
zJ0W5iSAgKIANY>Dz9VsG^5>JkJiIb+ZoOmVamUEh=(a`qQS`m%J`y`GfDZm2c8t6*
zu)zLJ^hBrsx1Es_y`fDT&8>yb!i%dzb(MljC`DdX>tOrKmCnq+nliJy$zWvrf;uO{
z>zwGOI!9D}ua%$wcXf_Wl{}fUb-s2#K~#TRTelWa18r>^bwIGK?W^kmsMEgpIv@;n
zfB-+ytp~zT4|FV~+SLOFe43Q>q@ClfsC^Um3XenzB_g3cKrq)Ir0~|si?}D@XCMPJ
z2@-K;jP^m}Jv(O~baFN@O*tD<wUx6WuX}Pfln!(cdXRbWd$VDNrlEmmfOyrzUf~cO
z#Acq)?M%79MW#$}?6B6X*=uIITS3KU8(g^YD<F09r=2~E2Ug_N(rzH1-&#Dd7T*Kh
za^G?{-nv)gsdd@@Uz1ZS@jb5SGMMCSlZWWUk{-*c#RC@m2>rXP>jTuw-EP+=21b85
zfw{PHn&S!}%D13Oiu}iz66Tl^*@P*AD*m5f3Zfr8AM47t!<6>;)4-JW_|w3Y_W1K^
zOo6Yz?;TS@FJVduFeTdl8$+L~n)B8-25o^Q^cXy7jwSR5$Q=h_!3RBoGQt2o38X~;
zck%${18CMqOi!!m^%$Tx;|m}Vx;u8Q$o-2H2n6o_wK#-u|I!pEtMUGI+5TUX`&Z%+
zehrPqW1!l)hv>qR9)rvM7W)XjyR7R2)Js!t*Cqx==V5yfj`_k&*7%2prm?VQpHu-K
z)wFB1TnRrxK#FT{_(csk7Axye^=K4NAm|Y!A0Zh5!n!rhFySL4ujNdW7N=_P;Gl1p
zrsYcj;Dut|%<J$qq(RZv;ZZ_20s0^3wHDoi{*WZ#XJ8`u$EWZhpNW$Hg77Tr_xC@G
ziT?C+S@bL45FmUhyoa)d$yg%dmlf@Yp6pG{s{2w_0)cW5veOM(G<6noRV--h=)2e_
z=AHni@BolvMZ<zsI17bCL5eX;@q`MW8$S@#u#v*~n?bQ|<|k-O)aI;o#+NgSdaU%V
za#H@#IuJZYCqaj6H_+l6pCAZ-B;;pgjdcHkZ2vv!_;a-L?)G1dtw(pSMt3h|zK-sx
phn@u_A^!Im2}D*RZ?E}#>f)1F=biHHay{}quvJht2oOHnzX6AIerf;!

literal 0
HcmV?d00001

diff --git a/technical-fundamentals/python/coding/problems/tests/trees/__pycache__/test_38_first_common_ancestor.cpython-314-pytest-9.0.3.pyc b/technical-fundamentals/python/coding/problems/tests/trees/__pycache__/test_38_first_common_ancestor.cpython-314-pytest-9.0.3.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c947e70a826d4051dfb76648541f9d06a7490ce1
GIT binary patch
literal 6196
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

literal 0
HcmV?d00001

diff --git a/technical-fundamentals/python/coding/problems/tests/trees/__pycache__/test_39_bst_sequences.cpython-314-pytest-9.0.3.pyc b/technical-fundamentals/python/coding/problems/tests/trees/__pycache__/test_39_bst_sequences.cpython-314-pytest-9.0.3.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..df11c033087181ef6895645b273d2d18a2d09644
GIT binary patch
literal 5623
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
a)M$GeYr8debF3kL8A@}xJp{!3>VE)4A_oru

literal 0
HcmV?d00001

diff --git a/technical-fundamentals/python/coding/problems/tests/trees/test_30_trees.py b/technical-fundamentals/python/coding/problems/tests/trees/test_30_trees.py
new file mode 100644
index 00000000..044e732e
--- /dev/null
+++ b/technical-fundamentals/python/coding/problems/tests/trees/test_30_trees.py
@@ -0,0 +1,40 @@
+import importlib.util
+from pathlib import Path
+
+_PROBLEMS = Path(__file__).parents[2]
+
+
+def _load(filename):
+    spec = importlib.util.spec_from_file_location(filename, _PROBLEMS / filename)
+    mod = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(mod)
+    return mod
+
+
+_m = _load("30_trees.py")
+Tree = _m.Tree
+TreeNode = _m.TreeNode
+
+
+class TestTrees:
+    def test_dfs_navigates_tree_in_order(self):
+        """dfs navigates the tree in order"""
+        root = TreeNode(1,
+            left=TreeNode(2, left=TreeNode(3), right=TreeNode(4)),
+            right=TreeNode(5, left=TreeNode(6, left=TreeNode(7)), right=TreeNode(8)),
+        )
+        tree = Tree()
+        order = []
+        tree.dfs(root, lambda node: order.append(node))
+        assert [n.value for n in order] == [1, 2, 3, 4, 5, 6, 7, 8]
+
+    def test_bfs_navigates_tree_in_order(self):
+        """bfs navigates the tree in order"""
+        root = TreeNode(1,
+            left=TreeNode(2, left=TreeNode(4), right=TreeNode(5)),
+            right=TreeNode(3, left=TreeNode(6, left=TreeNode(8)), right=TreeNode(7)),
+        )
+        tree = Tree()
+        order = []
+        tree.bfs(root, lambda node: order.append(node))
+        assert [n.value for n in order] == [1, 2, 3, 4, 5, 6, 7, 8]
diff --git a/technical-fundamentals/python/coding/problems/tests/trees/test_31_has_route_between_nodes.py b/technical-fundamentals/python/coding/problems/tests/trees/test_31_has_route_between_nodes.py
new file mode 100644
index 00000000..22e7e6bf
--- /dev/null
+++ b/technical-fundamentals/python/coding/problems/tests/trees/test_31_has_route_between_nodes.py
@@ -0,0 +1,40 @@
+import importlib.util
+from pathlib import Path
+
+_PROBLEMS = Path(__file__).parents[2]
+
+
+def _load(filename):
+    spec = importlib.util.spec_from_file_location(filename, _PROBLEMS / filename)
+    mod = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(mod)
+    return mod
+
+
+_m = _load("31_has_route_between_nodes.py")
+has_route_between_nodes = _m.has_route_between_nodes
+GraphNode = _m.GraphNode
+
+
+class TestHasRouteBetweenNodes:
+    def test_has_route_between_connected_nodes(self):
+        """has route between connected nodes"""
+        n1, n2, n3, n4, n5, n6 = (
+            GraphNode(1), GraphNode(2), GraphNode(3),
+            GraphNode(4), GraphNode(5), GraphNode(6),
+        )
+        n1.neighbors = [n2, n5]
+        n2.neighbors = [n3]
+        n3.neighbors = [n4, n6]
+        n6.neighbors = [n3]
+        assert has_route_between_nodes(n1, n4) == True
+        assert has_route_between_nodes(n4, n1) == False
+        assert has_route_between_nodes(n2, n5) == False
+        assert has_route_between_nodes(n1, n6) == True
+
+    def test_no_route_between_disconnected_nodes(self):
+        """no route between disconnected nodes"""
+        n1, n2, n3 = GraphNode(1), GraphNode(2), GraphNode(3)
+        assert has_route_between_nodes(n1, n2) == False
+        assert has_route_between_nodes(n2, n3) == False
+        assert has_route_between_nodes(n1, n3) == False
diff --git a/technical-fundamentals/python/coding/problems/tests/trees/test_32_minimal_tree.py b/technical-fundamentals/python/coding/problems/tests/trees/test_32_minimal_tree.py
new file mode 100644
index 00000000..77e9fa36
--- /dev/null
+++ b/technical-fundamentals/python/coding/problems/tests/trees/test_32_minimal_tree.py
@@ -0,0 +1,48 @@
+import importlib.util
+from pathlib import Path
+
+_PROBLEMS = Path(__file__).parents[2]
+
+
+def _load(filename):
+    spec = importlib.util.spec_from_file_location(filename, _PROBLEMS / filename)
+    mod = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(mod)
+    return mod
+
+
+_m = _load("32_minimal_tree.py")
+minimal_tree = _m.minimal_tree
+TreeNode = _m.TreeNode
+
+
+def _tree_equal(a, b):
+    if a is None and b is None:
+        return True
+    if a is None or b is None:
+        return False
+    return a.value == b.value and _tree_equal(a.left, b.left) and _tree_equal(a.right, b.right)
+
+
+class TestMinimalTree:
+    def test_creates_minimal_bst_from_3_elements(self):
+        """creates minimal height BST from sorted array"""
+        expected = TreeNode(2, left=TreeNode(1), right=TreeNode(3))
+        assert _tree_equal(minimal_tree([1, 2, 3]), expected)
+
+    def test_creates_minimal_bst_from_5_elements(self):
+        """creates minimal height BST from sorted array 5 length"""
+        expected = TreeNode(3, left=TreeNode(2, left=TreeNode(1)), right=TreeNode(5, left=TreeNode(4)))
+        assert _tree_equal(minimal_tree([1, 2, 3, 4, 5]), expected)
+
+    def test_creates_minimal_bst_from_7_elements(self):
+        """creates minimal height BST from sorted array 7 length"""
+        expected = TreeNode(4,
+            left=TreeNode(2, left=TreeNode(1), right=TreeNode(3)),
+            right=TreeNode(6, left=TreeNode(5), right=TreeNode(7)),
+        )
+        assert _tree_equal(minimal_tree([1, 2, 3, 4, 5, 6, 7]), expected)
+
+    def test_returns_none_for_empty_array(self):
+        """returns toBeUndefined for empty array"""
+        assert minimal_tree([]) is None
diff --git a/technical-fundamentals/python/coding/problems/tests/trees/test_33_list_of_depths.py b/technical-fundamentals/python/coding/problems/tests/trees/test_33_list_of_depths.py
new file mode 100644
index 00000000..fc180bc2
--- /dev/null
+++ b/technical-fundamentals/python/coding/problems/tests/trees/test_33_list_of_depths.py
@@ -0,0 +1,47 @@
+import importlib.util
+from pathlib import Path
+
+_PROBLEMS = Path(__file__).parents[2]
+
+
+def _load(filename):
+    spec = importlib.util.spec_from_file_location(filename, _PROBLEMS / filename)
+    mod = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(mod)
+    return mod
+
+
+_m = _load("33_list_of_depths.py")
+list_of_depths = _m.list_of_depths
+TreeNode = _m.TreeNode
+ListNode = _m.ListNode
+
+
+def _list_values(node):
+    vals = []
+    while node:
+        vals.append(node.value)
+        node = node.next
+    return vals
+
+
+class TestListOfDepths:
+    def test_creates_linked_lists_at_each_depth(self):
+        """creates linked lists of nodes at each depth"""
+        root = TreeNode(1,
+            left=TreeNode(2, left=TreeNode(4, left=TreeNode(7)), right=TreeNode(5)),
+            right=TreeNode(3, right=TreeNode(6)),
+        )
+        result = list_of_depths(root)
+        assert len(result) == 4
+        assert _list_values(result[0]) == [1]
+        assert _list_values(result[1]) == [2, 3]
+        assert _list_values(result[2]) == [4, 5, 6]
+        assert _list_values(result[3]) == [7]
+
+    def test_creates_linked_lists_for_single_node_tree(self):
+        """creates linked lists for single node tree"""
+        root = TreeNode(1)
+        result = list_of_depths(root)
+        assert len(result) == 1
+        assert _list_values(result[0]) == [1]
diff --git a/technical-fundamentals/python/coding/problems/tests/trees/test_34_check_balanced.py b/technical-fundamentals/python/coding/problems/tests/trees/test_34_check_balanced.py
new file mode 100644
index 00000000..1062a2d7
--- /dev/null
+++ b/technical-fundamentals/python/coding/problems/tests/trees/test_34_check_balanced.py
@@ -0,0 +1,35 @@
+import importlib.util
+from pathlib import Path
+
+_PROBLEMS = Path(__file__).parents[2]
+
+
+def _load(filename):
+    spec = importlib.util.spec_from_file_location(filename, _PROBLEMS / filename)
+    mod = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(mod)
+    return mod
+
+
+_m = _load("34_check_balanced.py")
+check_balanced = _m.check_balanced
+TreeNode = _m.TreeNode
+
+
+class TestCheckBalanced:
+    def test_returns_true_for_balanced_tree(self):
+        """returns true for a balanced tree"""
+        root = TreeNode(1,
+            left=TreeNode(2, left=TreeNode(4), right=TreeNode(5)),
+            right=TreeNode(3, left=TreeNode(6), right=TreeNode(7)),
+        )
+        assert check_balanced(root) == True
+
+    def test_returns_false_for_unbalanced_tree(self):
+        """returns false for an unbalanced tree"""
+        root = TreeNode(1, left=TreeNode(2, left=TreeNode(3, left=TreeNode(4))))
+        assert check_balanced(root) == False
+
+    def test_returns_true_for_empty_tree(self):
+        """returns true for an empty tree"""
+        assert check_balanced(None) == True
diff --git a/technical-fundamentals/python/coding/problems/tests/trees/test_35_validate_bst.py b/technical-fundamentals/python/coding/problems/tests/trees/test_35_validate_bst.py
new file mode 100644
index 00000000..22593c24
--- /dev/null
+++ b/technical-fundamentals/python/coding/problems/tests/trees/test_35_validate_bst.py
@@ -0,0 +1,44 @@
+import importlib.util
+from pathlib import Path
+
+_PROBLEMS = Path(__file__).parents[2]
+
+
+def _load(filename):
+    spec = importlib.util.spec_from_file_location(filename, _PROBLEMS / filename)
+    mod = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(mod)
+    return mod
+
+
+_m = _load("35_validate_bst.py")
+validate_bst = _m.validate_bst
+TreeNode = _m.TreeNode
+
+
+class TestValidateBST:
+    def test_returns_true_for_valid_bst(self):
+        """returns true for a valid BST"""
+        root = TreeNode(2, left=TreeNode(1), right=TreeNode(3))
+        assert validate_bst(root) == True
+
+    def test_returns_false_for_invalid_bst(self):
+        """returns false for an invalid BST"""
+        root = TreeNode(1, left=TreeNode(2), right=TreeNode(3))
+        assert validate_bst(root) == False
+
+    def test_returns_false_for_invalid_bst_2(self):
+        """returns false for an invalid BST #2"""
+        root = TreeNode(3,
+            left=TreeNode(2, left=TreeNode(1), right=TreeNode(4)),
+            right=TreeNode(5),
+        )
+        assert validate_bst(root) == False
+
+    def test_returns_true_for_empty_tree(self):
+        """returns true for an empty tree"""
+        assert validate_bst(None) == True
+
+    def test_returns_true_for_single_node(self):
+        """returns true for a single node tree"""
+        assert validate_bst(TreeNode(5)) == True
diff --git a/technical-fundamentals/python/coding/problems/tests/trees/test_36_successor.py b/technical-fundamentals/python/coding/problems/tests/trees/test_36_successor.py
new file mode 100644
index 00000000..6b2bc553
--- /dev/null
+++ b/technical-fundamentals/python/coding/problems/tests/trees/test_36_successor.py
@@ -0,0 +1,38 @@
+import importlib.util
+from pathlib import Path
+
+_PROBLEMS = Path(__file__).parents[2]
+
+
+def _load(filename):
+    spec = importlib.util.spec_from_file_location(filename, _PROBLEMS / filename)
+    mod = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(mod)
+    return mod
+
+
+_m = _load("36_successor.py")
+successor = _m.successor
+TreeNode = _m.TreeNode
+
+
+class TestSuccessor:
+    def test_returns_correct_in_order_successor(self):
+        """returns correct in-order successor"""
+        n2, n4, n6, n8 = TreeNode(2), TreeNode(4), TreeNode(6), TreeNode(8)
+        n3 = TreeNode(3, left=n2, right=n4)
+        n7 = TreeNode(7, left=n6, right=n8)
+        n5 = TreeNode(5, left=n3, right=n7)
+        n2.parent = n3; n4.parent = n3; n3.parent = n5
+        n6.parent = n7; n8.parent = n7; n7.parent = n5
+        assert successor(n2).value == 3
+        assert successor(n3).value == 4
+        assert successor(n4).value == 5
+        assert successor(n5).value == 6
+        assert successor(n6).value == 7
+        assert successor(n7).value == 8
+        assert successor(n8) is None
+
+    def test_returns_none_for_node_without_successor(self):
+        """returns undefined for node without successor"""
+        assert successor(TreeNode(1)) is None
diff --git a/technical-fundamentals/python/coding/problems/tests/trees/test_37_build_order.py b/technical-fundamentals/python/coding/problems/tests/trees/test_37_build_order.py
new file mode 100644
index 00000000..a7bea51c
--- /dev/null
+++ b/technical-fundamentals/python/coding/problems/tests/trees/test_37_build_order.py
@@ -0,0 +1,39 @@
+import importlib.util
+from pathlib import Path
+import pytest
+
+_PROBLEMS = Path(__file__).parents[2]
+
+
+def _load(filename):
+    spec = importlib.util.spec_from_file_location(filename, _PROBLEMS / filename)
+    mod = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(mod)
+    return mod
+
+
+_m = _load("37_build_order.py")
+build_order = _m.build_order
+
+
+class TestBuildOrder:
+    def test_returns_correct_build_order(self):
+        """returns correct build order for valid input"""
+        projects = ["a", "b", "c", "d", "e", "f"]
+        deps = [["a", "d"], ["f", "b"], ["b", "d"], ["f", "a"], ["d", "c"]]
+        assert build_order(projects, deps) == ["e", "f", "a", "b", "d", "c"]
+
+    def test_raises_error_for_no_valid_order(self):
+        """throws error for no valid order"""
+        projects = ["a", "b", "c", "d", "e"]
+        deps = [["a", "d"], ["f", "b"], ["b", "d"], ["f", "a"], ["d", "c"]]
+        with pytest.raises(Exception, match="No valid build order exists"):
+            build_order(projects, deps)
+
+    def test_single_project(self):
+        """returns correct build order for single project"""
+        assert build_order(["a"], []) == ["a"]
+
+    def test_empty_input(self):
+        """returns correct build order for empty input"""
+        assert build_order([], []) == []
diff --git a/technical-fundamentals/python/coding/problems/tests/trees/test_38_first_common_ancestor.py b/technical-fundamentals/python/coding/problems/tests/trees/test_38_first_common_ancestor.py
new file mode 100644
index 00000000..e1ea94a6
--- /dev/null
+++ b/technical-fundamentals/python/coding/problems/tests/trees/test_38_first_common_ancestor.py
@@ -0,0 +1,28 @@
+import importlib.util
+from pathlib import Path
+
+_PROBLEMS = Path(__file__).parents[2]
+
+
+def _load(filename):
+    spec = importlib.util.spec_from_file_location(filename, _PROBLEMS / filename)
+    mod = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(mod)
+    return mod
+
+
+_m = _load("38_first_common_ancestor.py")
+first_common_ancestor = _m.first_common_ancestor
+TreeNode = _m.TreeNode
+
+
+class TestFirstCommonAncestor:
+    def test_returns_correct_common_ancestor(self):
+        """returns correct common ancestor for valid input"""
+        n4, n5, n6, n7 = TreeNode(4), TreeNode(5), TreeNode(6), TreeNode(7)
+        n2 = TreeNode(2, left=n4, right=n5)
+        n3 = TreeNode(3, left=n6, right=n7)
+        root = TreeNode(1, left=n2, right=n3)
+        assert first_common_ancestor(root, n2, n3) is root
+        assert first_common_ancestor(root, n4, n5) is n2
+        assert first_common_ancestor(root, n4, n7) is root
diff --git a/technical-fundamentals/python/coding/problems/tests/trees/test_39_bst_sequences.py b/technical-fundamentals/python/coding/problems/tests/trees/test_39_bst_sequences.py
new file mode 100644
index 00000000..5c9209d8
--- /dev/null
+++ b/technical-fundamentals/python/coding/problems/tests/trees/test_39_bst_sequences.py
@@ -0,0 +1,36 @@
+import importlib.util
+from pathlib import Path
+
+_PROBLEMS = Path(__file__).parents[2]
+
+
+def _load(filename):
+    spec = importlib.util.spec_from_file_location(filename, _PROBLEMS / filename)
+    mod = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(mod)
+    return mod
+
+
+_m = _load("39_bst_sequences.py")
+bst_sequences = _m.bst_sequences
+TreeNode = _m.TreeNode
+
+
+class TestBstSequences:
+    def test_returns_correct_sequences_for_3_nodes(self):
+        """returns correct sequences for valid input with 3 nodes"""
+        root = TreeNode(2, left=TreeNode(1), right=TreeNode(3))
+        result = bst_sequences(root)
+        assert [2, 1, 3] in result
+        assert [2, 3, 1] in result
+
+    def test_returns_correct_sequences_for_7_nodes(self):
+        """returns correct sequences for valid input"""
+        root = TreeNode(5,
+            left=TreeNode(3, left=TreeNode(2), right=TreeNode(4)),
+            right=TreeNode(7, left=TreeNode(6), right=TreeNode(8)),
+        )
+        result = bst_sequences(root)
+        assert len(result) == 80
+        assert [5, 3, 7, 2, 4, 6, 8] in result
+        assert [5, 7, 3, 2, 4, 6, 8] in result
diff --git a/technical-fundamentals/python/coding/problems/tools/add_js_docstrings.py b/technical-fundamentals/python/coding/problems/tools/add_js_docstrings.py
new file mode 100644
index 00000000..65d8d807
--- /dev/null
+++ b/technical-fundamentals/python/coding/problems/tools/add_js_docstrings.py
@@ -0,0 +1,61 @@
+#!/usr/bin/env python3
+"""Auto-insert docstrings into Python tests based on corresponding JS test names."""
+import re
+from pathlib import Path
+
+PY_ROOT = Path("/Users/mativs/Projects/100k/interview-ready/technical-fundamentals/python/coding/problems/tests")
+JS_ROOT = Path("/Users/mativs/Projects/100k/interview-ready/technical-fundamentals/coding/problems/__tests__")
+
+def extract_js_test_names(js_file: Path) -> list:
+    if not js_file.exists():
+        return []
+    content = js_file.read_text(encoding='utf-8')
+    return re.findall(r'test\(\s*["\'](.*?)["\']', content)
+
+def process_file(py_file: Path):
+    rel = py_file.relative_to(PY_ROOT)
+    stem = py_file.stem
+    m = re.match(r'test_(\d+)_(.+)', stem)
+    if not m:
+        return False
+    
+    num = m.group(1)
+    js_dir = JS_ROOT / rel.parent
+    js_candidates = list(js_dir.glob(f"{num}_*.test.ts"))
+    if not js_candidates:
+        return False
+    
+    js_file = js_candidates[0]
+    js_names = extract_js_test_names(js_file)
+    
+    if not js_names:
+        return False
+    
+    lines = py_file.read_text(encoding='utf-8').splitlines(True)
+    
+    new_lines = []
+    js_idx = 0
+    
+    for line in lines:
+        new_lines.append(line)
+        m = re.match(r'(\s+)def\s+(test_\w+)\(self\):', line)
+        if m and js_idx < len(js_names):
+            indent = m.group(1)
+            js_name = js_names[js_idx]
+            new_lines.append(f'{indent}    """{js_name}"""\n')
+            js_idx += 1
+    
+    py_file.write_text("".join(new_lines), encoding='utf-8')
+    return True
+
+def main():
+    py_files = sorted(PY_ROOT.glob("**/test_*.py"))
+    success = 0
+    for py_file in py_files:
+        if process_file(py_file):
+            success += 1
+    
+    print(f"Processed {success}/{len(py_files)} files")
+
+if __name__ == '__main__':
+    main()
diff --git a/technical-fundamentals/python/coding/problems/tools/fix_docstrings.py b/technical-fundamentals/python/coding/problems/tools/fix_docstrings.py
new file mode 100644
index 00000000..368c848c
--- /dev/null
+++ b/technical-fundamentals/python/coding/problems/tools/fix_docstrings.py
@@ -0,0 +1,87 @@
+#!/usr/bin/env python3
+"""Fix Python test docstrings to match JS test names exactly."""
+import re
+from pathlib import Path
+
+PY_ROOT = Path("/Users/mativs/Projects/100k/interview-ready/technical-fundamentals/python/coding/problems/tests")
+JS_ROOT = Path("/Users/mativs/Projects/100k/interview-ready/technical-fundamentals/coding/problems/__tests__")
+
+def extract_js_test_names(js_file: Path) -> list:
+    if not js_file.exists():
+        return []
+    content = js_file.read_text(encoding='utf-8')
+    return re.findall(r'test\(\s*["\'](.*?)["\']', content)
+
+def fix_file(py_file: Path):
+    # Find corresponding JS file
+    rel = py_file.relative_to(PY_ROOT)
+    stem = py_file.stem
+    m = re.match(r'test_(\d+)_(.+)', stem)
+    if not m:
+        return False
+    
+    num = m.group(1)
+    js_dir = JS_ROOT / rel.parent
+    js_candidates = list(js_dir.glob(f"{num}_*.test.ts"))
+    if not js_candidates:
+        return False
+    
+    js_file = js_candidates[0]
+    js_names = extract_js_test_names(js_file)
+    
+    if not js_names:
+        return False
+    
+    lines = py_file.read_text(encoding='utf-8').splitlines(True)
+    new_lines = []
+    js_idx = 0
+    i = 0
+    
+    while i < len(lines):
+        line = lines[i]
+        # Check if this is a test method definition
+        method_match = re.match(r'(\s+)def\s+(test_\w+)\(self\):', line)
+        
+        if method_match and js_idx < len(js_names):
+            indent = method_match.group(1)
+            new_lines.append(line)
+            
+            # Skip any existing docstrings (triple-quoted strings right after def)
+            i += 1
+            while i < len(lines) and (lines[i].strip().startswith('"""') or lines[i].strip() == ''):
+                if lines[i].strip().startswith('"""'):
+                    # Skip the entire docstring
+                    if lines[i].strip() == '"""':
+                        i += 1
+                        while i < len(lines) and not lines[i].strip().endswith('"""'):
+                            i += 1
+                        i += 1
+                    else:
+                        # Single-line docstring
+                        i += 1
+                else:
+                    i += 1
+            
+            # Add the correct docstring
+            js_name = js_names[js_idx]
+            new_lines.append(f'{indent}    """{js_name}"""\n')
+            js_idx += 1
+            continue
+        else:
+            new_lines.append(line)
+            i += 1
+    
+    py_file.write_text("".join(new_lines), encoding='utf-8')
+    return True
+
+def main():
+    py_files = sorted(PY_ROOT.glob("**/test_*.py"))
+    success = 0
+    for py_file in py_files:
+        if fix_file(py_file):
+            success += 1
+    
+    print(f"Fixed {success}/{len(py_files)} files")
+
+if __name__ == '__main__':
+    main()
diff --git a/technical-fundamentals/python/coding/problems/utils/__init__.py b/technical-fundamentals/python/coding/problems/utils/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/technical-fundamentals/python/coding/problems/utils/__pycache__/__init__.cpython-314.pyc b/technical-fundamentals/python/coding/problems/utils/__pycache__/__init__.cpython-314.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..9860fd39e00e613fe8b4a0af6952c67917f54ea5
GIT binary patch
literal 206
zcmXwzK?=e!5JeM<B7z=5S0Z)lUOa+`;JU<iv}4<(Bx$8Puj7@v^#*q3&II%?{=Cm$
z%wNr>6Xs;*AM*F*?Jxd=e&pc6j%>k}eE(#6;BxQFE{BsrZJ-pE8UqKdZkSjDn<&bG
zq($8j-b0NdZNXxaNlHW!UTT?&5~US|fvUBcl8~sB<P|Ed&IOhRYD=z+W0GX!cwM#K
Ycw4HpE^w!Z?zdlOJiG(WxegqC0b@)!0ssI2

literal 0
HcmV?d00001

diff --git a/technical-fundamentals/python/coding/problems/utils/__pycache__/strings.cpython-314.pyc b/technical-fundamentals/python/coding/problems/utils/__pycache__/strings.cpython-314.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..a6d8c7027f7af131bdf4915c45ec4c93c1e033f2
GIT binary patch
literal 1912
zcmah}&2Jl35TCcZc8u%hv&E%EiPJ(7Cyh6y5ws9h4HYR!C@LFTE@@Vq^|s!2y=%Sq
zTyRbn;!q?G9698`p%<ha`9lm*rD(+sB*ZNtDk(Q+-o_tMi!##to;PpaZ+<hg{im~l
zA};*v*EE3NY0(y3D>=B0g9A;l(s_`5^B}<j$=1PQpJ*TJQXdCP%Y&uoAsCd#J!1kE
zj;@N-Jy?fF3^feYNGXl9)prq!nN2TyNBV&;8-@E3FVuLn5qQ<Y{I&NBtCIWSgMt-F
zNBU7%%KE|<^$n41yG~e$!k|&u@CvRI1YQ}Ju2-meT`PVlq=TEKY>~y8o2ccWb(f)E
z)JP0$I<^A~yC&R)b?xdm0A<`8h0j=pS!@kY5?O150o_?iTO%7vu4tFex90#R!w+hI
z(VaNWJz3{rQRix@<0oQcBZ>laER7$pI#Q5J7vhKJ9pQ0d;*S4Vn74WK&~v3QFVD|E
zGW}3`{ITzSImbPx+%To*Rze@YKX<<#mYu2>N+%FztsyH>Xu44u0W^;=6=ofQ7G{E<
zDAgKq&bFN}Bz!&F=EQ;5u!#xmns5kNc5a`#t;)8(z53(k&kL=o_nwViRhtK>1TJ-L
zAs7{uV>odbG6f=pFAsOw6-L|$GQnUCAx2pA<zrDu<Bbt)2aDL96a`D`M#R#)kuY^M
zY;cN3tclCm-r*@+6g5uvc^}Og&)|??&FQ!5+wqL;BBBUGFULxYL4??f>!n_ta&*59
zQ7VNHVYfB1N5j*LYS?~DZSqs7>UKDT3xY@e^Ie=QB1Eg&6wXM>Xm=FW+Pp;Y7LMk`
z!ASdJ@EU3nqc-2}b#l6h^baWu>O$oJrUWHI>2su3&Z>vfuX-PG9&sdJKbqhJ*v082
zX9RgPIoVWD#JOI>Ct=d7t1zLkzi7grr-ptT9&3#+?+o8+<!<c`oqdwt9T@udt0w~r
zke?_ZXUGvkLJ&NK8_D};UKItNM-9bG$}N0g_w;ac`OrYP71(?IkUQ5h@(J36SsOz#
ztq3`alUK9K(o~k}iZzNYEBtlT{vVzwvb=%kf_$eO(b&vBbw5ZoBu?O2M><ZB_syOF
zcd8?^D6DJ+VWF=k*pL&-Sc1%1WTz1RgYXzZIoVY1Q0_M2kCCaJk>b~%z6^zd=L(8Y
zDZX6hOsvq|v?8jNClnz&^zD|p?hK0`rIwQ8#qR^nVw1Q}giXMukQa^kP1|;(u<TPw
zcY=2P!G*vQM30@AtSSf;V=;#v1wm)VK6QsPz&>QZ!qRt@Eq!bC`^~2dt^Cxp{^?&}
z>F-%oP{6DdGn^O^_t|zia&0?K%SH_=W%7JC286D94B0>zRMj}5YG$z-mFt0bosZ**
r@@5(*FZOiC*gqP+^*jq~^m&?!=y|wwgYC>NHFG<#beKlEC`bMS<THar

literal 0
HcmV?d00001

diff --git a/technical-fundamentals/python/coding/problems/utils/strings.py b/technical-fundamentals/python/coding/problems/utils/strings.py
new file mode 100644
index 00000000..d8daa1a3
--- /dev/null
+++ b/technical-fundamentals/python/coding/problems/utils/strings.py
@@ -0,0 +1,27 @@
+"""
+Utility for problem 09: String Rotation.
+is_substring can only be called once per problem instance.
+"""
+
+from typing import Callable
+
+
+def _create_is_substring() -> Callable[[str, str], bool]:
+    called = False
+
+    def is_substring(s1: str, s2: str) -> bool:
+        nonlocal called
+        if called:
+            raise RuntimeError("is_substring() can be used only once.")
+        called = True
+        return s2 in s1
+
+    return is_substring
+
+
+is_substring: Callable[[str, str], bool] = _create_is_substring()
+
+
+def reassign_is_substring() -> None:
+    global is_substring
+    is_substring = _create_is_substring()
diff --git a/technical-fundamentals/python/conftest.py b/technical-fundamentals/python/conftest.py
new file mode 100644
index 00000000..8fc48019
--- /dev/null
+++ b/technical-fundamentals/python/conftest.py
@@ -0,0 +1,50 @@
+import hashlib
+from pathlib import Path
+
+PROBLEMS_DIR = Path(__file__).parent / "coding" / "problems"
+
+
+_JS_TEST_PATH_MAP = {
+    "test_01_is_unique": "coding/problems/__tests__/strings/01_isUnique.test.ts",
+    "test_02_check_permutations": "coding/problems/__tests__/strings/02_checkPermutations.test.ts",
+    "test_03_urlify": "coding/problems/__tests__/strings/03_URLify.test.ts",
+    "test_04_palindrome_permutation": "coding/problems/__tests__/strings/04_palindromePermutation.test.ts",
+    "test_05_one_away": "coding/problems/__tests__/strings/05_oneAway.test.ts",
+    "test_06_string_compression": "coding/problems/__tests__/strings/06_stringCompression.test.ts",
+    "test_07_rotate_matrix": "coding/problems/__tests__/strings/07_rotateMatrix.test.ts",
+    "test_08_zero_matrix": "coding/problems/__tests__/strings/08_zeroMatrix.test.ts",
+    "test_09_string_rotation": "coding/problems/__tests__/strings/09_stringRotation.test.ts",
+}
+
+
+def hs(reports):
+    paths = set()
+    for report in reports:
+        parts = report.nodeid.split("::")
+        file_name = parts[0].split("/")[-1].replace(".py", "")
+        js_path = _JS_TEST_PATH_MAP.get(file_name)
+        if js_path:
+            paths.add(js_path)
+
+    sorted_paths = sorted(paths)
+    string = "".join(sorted_paths)
+    return hashlib.md5(string.encode()).hexdigest()
+
+
+def pytest_terminal_summary(terminalreporter, exitstatus, config):
+    passed = terminalreporter.stats.get("passed", [])
+    failed = terminalreporter.stats.get("failed", [])
+    has_failures = len(failed) > 0
+
+    if has_failures:
+        terminalreporter.write_line(
+            "\x1b[31m\x1b[1m❌ Some tests failed. To pass on Interview Ready, you need the password after all tests passed!\x1b[0m"
+        )
+    else:
+        password = hs(passed)
+        terminalreporter.write_line(
+            "\x1b[32m\x1b[1m✨ All tests passed! Great job! 🎉\x1b[0m"
+        )
+        terminalreporter.write_line(
+            f"\x1b[32m\x1b[1m✨ Use this password for your Interview Ready Submission: {password} \x1b[0m"
+        )
diff --git a/technical-fundamentals/python/pytest.ini b/technical-fundamentals/python/pytest.ini
new file mode 100644
index 00000000..912d70a2
--- /dev/null
+++ b/technical-fundamentals/python/pytest.ini
@@ -0,0 +1,5 @@
+[pytest]
+testpaths = coding/problems/tests
+python_files = test_*.py
+python_classes = Test*
+python_functions = test_*
diff --git a/technical-fundamentals/python/requirements.txt b/technical-fundamentals/python/requirements.txt
new file mode 100644
index 00000000..e079f8a6
--- /dev/null
+++ b/technical-fundamentals/python/requirements.txt
@@ -0,0 +1 @@
+pytest

From 780ea77000467607745c92e7b370d76117b4024d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Mat=C3=ADas=20Saguir?= <mativs@kamipay.io>
Date: Tue, 12 May 2026 21:53:21 -0300
Subject: [PATCH 13/14] revmoe pycache files

---
 .gitignore                                      |   1 +
 .../__pycache__/01_is_unique.cpython-314.pyc    | Bin 596 -> 0 bytes
 .../02_check_permutations.cpython-314.pyc       | Bin 947 -> 0 bytes
 .../__pycache__/03_urlify.cpython-314.pyc       | Bin 627 -> 0 bytes
 .../04_palindrome_permutation.cpython-314.pyc   | Bin 795 -> 0 bytes
 .../__pycache__/05_one_away.cpython-314.pyc     | Bin 1207 -> 0 bytes
 .../06_string_compression.cpython-314.pyc       | Bin 1034 -> 0 bytes
 .../07_rotate_matrix.cpython-314.pyc            | Bin 1411 -> 0 bytes
 .../__pycache__/08_zero_matrix.cpython-314.pyc  | Bin 1678 -> 0 bytes
 .../09_string_rotation.cpython-314.pyc          | Bin 644 -> 0 bytes
 .../__pycache__/11_remove_dups.cpython-314.pyc  | Bin 1318 -> 0 bytes
 .../__pycache__/12_kth_to_last.cpython-314.pyc  | Bin 1337 -> 0 bytes
 .../13_delete_middle_node.cpython-314.pyc       | Bin 1358 -> 0 bytes
 .../__pycache__/14_partition.cpython-314.pyc    | Bin 1325 -> 0 bytes
 .../__pycache__/15_sum_lists.cpython-314.pyc    | Bin 1230 -> 0 bytes
 .../16_sum_lists_forward_order.cpython-314.pyc  | Bin 1258 -> 0 bytes
 .../__pycache__/17_palindrome.cpython-314.pyc   | Bin 1310 -> 0 bytes
 .../__pycache__/18_intersection.cpython-314.pyc | Bin 1336 -> 0 bytes
 .../19_loop_detection.cpython-314.pyc           | Bin 1307 -> 0 bytes
 .../__pycache__/21_three_stacks.cpython-314.pyc | Bin 1935 -> 0 bytes
 .../__pycache__/22_stack_min.cpython-314.pyc    | Bin 1616 -> 0 bytes
 .../23_stack_of_plates.cpython-314.pyc          | Bin 1566 -> 0 bytes
 .../24_queue_via_stacks.cpython-314.pyc         | Bin 1929 -> 0 bytes
 .../__pycache__/25_sort_stack.cpython-314.pyc   | Bin 1923 -> 0 bytes
 .../26_animal_shelter.cpython-314.pyc           | Bin 2449 -> 0 bytes
 .../__pycache__/30_trees.cpython-314.pyc        | Bin 1958 -> 0 bytes
 .../31_has_route_between_nodes.cpython-314.pyc  | Bin 1307 -> 0 bytes
 .../__pycache__/32_minimal_tree.cpython-314.pyc | Bin 1415 -> 0 bytes
 .../33_list_of_depths.cpython-314.pyc           | Bin 1985 -> 0 bytes
 .../34_check_balanced.cpython-314.pyc           | Bin 1393 -> 0 bytes
 .../__pycache__/35_validate_bst.cpython-314.pyc | Bin 1389 -> 0 bytes
 .../__pycache__/36_successor.cpython-314.pyc    | Bin 1446 -> 0 bytes
 .../__pycache__/37_build_order.cpython-314.pyc  | Bin 766 -> 0 bytes
 .../38_first_common_ancestor.cpython-314.pyc    | Bin 1463 -> 0 bytes
 .../39_bst_sequences.cpython-314.pyc            | Bin 1404 -> 0 bytes
 .../__pycache__/41_triple_steps.cpython-314.pyc | Bin 500 -> 0 bytes
 .../42_robot_in_a_grid.cpython-314.pyc          | Bin 769 -> 0 bytes
 .../__pycache__/43_magic_index.cpython-314.pyc  | Bin 973 -> 0 bytes
 .../__pycache__/44_power_set.cpython-314.pyc    | Bin 621 -> 0 bytes
 .../45_recursive_multiply.cpython-314.pyc       | Bin 541 -> 0 bytes
 .../46_towers_of_hanoi.cpython-314.pyc          | Bin 671 -> 0 bytes
 .../47_permutations_with_dups.cpython-314.pyc   | Bin 899 -> 0 bytes
 .../__pycache__/48_coin_change.cpython-314.pyc  | Bin 610 -> 0 bytes
 .../__pycache__/__init__.cpython-314.pyc        | Bin 200 -> 0 bytes
 .../lists/__pycache__/__init__.cpython-314.pyc  | Bin 212 -> 0 bytes
 ..._11_remove_dups.cpython-314-pytest-9.0.3.pyc | Bin 8120 -> 0 bytes
 ..._12_kth_to_last.cpython-314-pytest-9.0.3.pyc | Bin 6787 -> 0 bytes
 ...ete_middle_node.cpython-314-pytest-9.0.3.pyc | Bin 10016 -> 0 bytes
 ...st_14_partition.cpython-314-pytest-9.0.3.pyc | Bin 10295 -> 0 bytes
 ...st_15_sum_lists.cpython-314-pytest-9.0.3.pyc | Bin 7508 -> 0 bytes
 ...s_forward_order.cpython-314-pytest-9.0.3.pyc | Bin 14258 -> 0 bytes
 ...t_17_palindrome.cpython-314-pytest-9.0.3.pyc | Bin 7034 -> 0 bytes
 ...18_intersection.cpython-314-pytest-9.0.3.pyc | Bin 8103 -> 0 bytes
 ..._loop_detection.cpython-314-pytest-9.0.3.pyc | Bin 7661 -> 0 bytes
 .../__pycache__/__init__.cpython-314.pyc        | Bin 216 -> 0 bytes
 ...41_triple_steps.cpython-314-pytest-9.0.3.pyc | Bin 7537 -> 0 bytes
 ...robot_in_a_grid.cpython-314-pytest-9.0.3.pyc | Bin 5059 -> 0 bytes
 ..._43_magic_index.cpython-314-pytest-9.0.3.pyc | Bin 5086 -> 0 bytes
 ...st_44_power_set.cpython-314-pytest-9.0.3.pyc | Bin 7076 -> 0 bytes
 ...ursive_multiply.cpython-314-pytest-9.0.3.pyc | Bin 5587 -> 0 bytes
 ...towers_of_hanoi.cpython-314-pytest-9.0.3.pyc | Bin 4022 -> 0 bytes
 ...tions_with_dups.cpython-314-pytest-9.0.3.pyc | Bin 5159 -> 0 bytes
 ..._48_coin_change.cpython-314-pytest-9.0.3.pyc | Bin 5846 -> 0 bytes
 .../stacks/__pycache__/__init__.cpython-314.pyc | Bin 213 -> 0 bytes
 ...21_three_stacks.cpython-314-pytest-9.0.3.pyc | Bin 18237 -> 0 bytes
 ...st_22_stack_min.cpython-314-pytest-9.0.3.pyc | Bin 19252 -> 0 bytes
 ...stack_of_plates.cpython-314-pytest-9.0.3.pyc | Bin 14650 -> 0 bytes
 ...ueue_via_stacks.cpython-314-pytest-9.0.3.pyc | Bin 14750 -> 0 bytes
 ...t_25_sort_stack.cpython-314-pytest-9.0.3.pyc | Bin 14076 -> 0 bytes
 ..._animal_shelter.cpython-314-pytest-9.0.3.pyc | Bin 8150 -> 0 bytes
 .../trees/__pycache__/__init__.cpython-314.pyc  | Bin 212 -> 0 bytes
 .../test_30_trees.cpython-314-pytest-9.0.3.pyc  | Bin 3927 -> 0 bytes
 ...e_between_nodes.cpython-314-pytest-9.0.3.pyc | Bin 9672 -> 0 bytes
 ...32_minimal_tree.cpython-314-pytest-9.0.3.pyc | Bin 7622 -> 0 bytes
 ..._list_of_depths.cpython-314-pytest-9.0.3.pyc | Bin 8095 -> 0 bytes
 ..._check_balanced.cpython-314-pytest-9.0.3.pyc | Bin 5214 -> 0 bytes
 ...35_validate_bst.cpython-314-pytest-9.0.3.pyc | Bin 7633 -> 0 bytes
 ...st_36_successor.cpython-314-pytest-9.0.3.pyc | Bin 9972 -> 0 bytes
 ..._37_build_order.cpython-314-pytest-9.0.3.pyc | Bin 5798 -> 0 bytes
 ...common_ancestor.cpython-314-pytest-9.0.3.pyc | Bin 6196 -> 0 bytes
 ...9_bst_sequences.cpython-314-pytest-9.0.3.pyc | Bin 5623 -> 0 bytes
 81 files changed, 1 insertion(+)
 delete mode 100644 technical-fundamentals/python/coding/problems/__pycache__/01_is_unique.cpython-314.pyc
 delete mode 100644 technical-fundamentals/python/coding/problems/__pycache__/02_check_permutations.cpython-314.pyc
 delete mode 100644 technical-fundamentals/python/coding/problems/__pycache__/03_urlify.cpython-314.pyc
 delete mode 100644 technical-fundamentals/python/coding/problems/__pycache__/04_palindrome_permutation.cpython-314.pyc
 delete mode 100644 technical-fundamentals/python/coding/problems/__pycache__/05_one_away.cpython-314.pyc
 delete mode 100644 technical-fundamentals/python/coding/problems/__pycache__/06_string_compression.cpython-314.pyc
 delete mode 100644 technical-fundamentals/python/coding/problems/__pycache__/07_rotate_matrix.cpython-314.pyc
 delete mode 100644 technical-fundamentals/python/coding/problems/__pycache__/08_zero_matrix.cpython-314.pyc
 delete mode 100644 technical-fundamentals/python/coding/problems/__pycache__/09_string_rotation.cpython-314.pyc
 delete mode 100644 technical-fundamentals/python/coding/problems/__pycache__/11_remove_dups.cpython-314.pyc
 delete mode 100644 technical-fundamentals/python/coding/problems/__pycache__/12_kth_to_last.cpython-314.pyc
 delete mode 100644 technical-fundamentals/python/coding/problems/__pycache__/13_delete_middle_node.cpython-314.pyc
 delete mode 100644 technical-fundamentals/python/coding/problems/__pycache__/14_partition.cpython-314.pyc
 delete mode 100644 technical-fundamentals/python/coding/problems/__pycache__/15_sum_lists.cpython-314.pyc
 delete mode 100644 technical-fundamentals/python/coding/problems/__pycache__/16_sum_lists_forward_order.cpython-314.pyc
 delete mode 100644 technical-fundamentals/python/coding/problems/__pycache__/17_palindrome.cpython-314.pyc
 delete mode 100644 technical-fundamentals/python/coding/problems/__pycache__/18_intersection.cpython-314.pyc
 delete mode 100644 technical-fundamentals/python/coding/problems/__pycache__/19_loop_detection.cpython-314.pyc
 delete mode 100644 technical-fundamentals/python/coding/problems/__pycache__/21_three_stacks.cpython-314.pyc
 delete mode 100644 technical-fundamentals/python/coding/problems/__pycache__/22_stack_min.cpython-314.pyc
 delete mode 100644 technical-fundamentals/python/coding/problems/__pycache__/23_stack_of_plates.cpython-314.pyc
 delete mode 100644 technical-fundamentals/python/coding/problems/__pycache__/24_queue_via_stacks.cpython-314.pyc
 delete mode 100644 technical-fundamentals/python/coding/problems/__pycache__/25_sort_stack.cpython-314.pyc
 delete mode 100644 technical-fundamentals/python/coding/problems/__pycache__/26_animal_shelter.cpython-314.pyc
 delete mode 100644 technical-fundamentals/python/coding/problems/__pycache__/30_trees.cpython-314.pyc
 delete mode 100644 technical-fundamentals/python/coding/problems/__pycache__/31_has_route_between_nodes.cpython-314.pyc
 delete mode 100644 technical-fundamentals/python/coding/problems/__pycache__/32_minimal_tree.cpython-314.pyc
 delete mode 100644 technical-fundamentals/python/coding/problems/__pycache__/33_list_of_depths.cpython-314.pyc
 delete mode 100644 technical-fundamentals/python/coding/problems/__pycache__/34_check_balanced.cpython-314.pyc
 delete mode 100644 technical-fundamentals/python/coding/problems/__pycache__/35_validate_bst.cpython-314.pyc
 delete mode 100644 technical-fundamentals/python/coding/problems/__pycache__/36_successor.cpython-314.pyc
 delete mode 100644 technical-fundamentals/python/coding/problems/__pycache__/37_build_order.cpython-314.pyc
 delete mode 100644 technical-fundamentals/python/coding/problems/__pycache__/38_first_common_ancestor.cpython-314.pyc
 delete mode 100644 technical-fundamentals/python/coding/problems/__pycache__/39_bst_sequences.cpython-314.pyc
 delete mode 100644 technical-fundamentals/python/coding/problems/__pycache__/41_triple_steps.cpython-314.pyc
 delete mode 100644 technical-fundamentals/python/coding/problems/__pycache__/42_robot_in_a_grid.cpython-314.pyc
 delete mode 100644 technical-fundamentals/python/coding/problems/__pycache__/43_magic_index.cpython-314.pyc
 delete mode 100644 technical-fundamentals/python/coding/problems/__pycache__/44_power_set.cpython-314.pyc
 delete mode 100644 technical-fundamentals/python/coding/problems/__pycache__/45_recursive_multiply.cpython-314.pyc
 delete mode 100644 technical-fundamentals/python/coding/problems/__pycache__/46_towers_of_hanoi.cpython-314.pyc
 delete mode 100644 technical-fundamentals/python/coding/problems/__pycache__/47_permutations_with_dups.cpython-314.pyc
 delete mode 100644 technical-fundamentals/python/coding/problems/__pycache__/48_coin_change.cpython-314.pyc
 delete mode 100644 technical-fundamentals/python/coding/problems/__pycache__/__init__.cpython-314.pyc
 delete mode 100644 technical-fundamentals/python/coding/problems/tests/lists/__pycache__/__init__.cpython-314.pyc
 delete mode 100644 technical-fundamentals/python/coding/problems/tests/lists/__pycache__/test_11_remove_dups.cpython-314-pytest-9.0.3.pyc
 delete mode 100644 technical-fundamentals/python/coding/problems/tests/lists/__pycache__/test_12_kth_to_last.cpython-314-pytest-9.0.3.pyc
 delete mode 100644 technical-fundamentals/python/coding/problems/tests/lists/__pycache__/test_13_delete_middle_node.cpython-314-pytest-9.0.3.pyc
 delete mode 100644 technical-fundamentals/python/coding/problems/tests/lists/__pycache__/test_14_partition.cpython-314-pytest-9.0.3.pyc
 delete mode 100644 technical-fundamentals/python/coding/problems/tests/lists/__pycache__/test_15_sum_lists.cpython-314-pytest-9.0.3.pyc
 delete mode 100644 technical-fundamentals/python/coding/problems/tests/lists/__pycache__/test_16_sum_lists_forward_order.cpython-314-pytest-9.0.3.pyc
 delete mode 100644 technical-fundamentals/python/coding/problems/tests/lists/__pycache__/test_17_palindrome.cpython-314-pytest-9.0.3.pyc
 delete mode 100644 technical-fundamentals/python/coding/problems/tests/lists/__pycache__/test_18_intersection.cpython-314-pytest-9.0.3.pyc
 delete mode 100644 technical-fundamentals/python/coding/problems/tests/lists/__pycache__/test_19_loop_detection.cpython-314-pytest-9.0.3.pyc
 delete mode 100644 technical-fundamentals/python/coding/problems/tests/recursion/__pycache__/__init__.cpython-314.pyc
 delete mode 100644 technical-fundamentals/python/coding/problems/tests/recursion/__pycache__/test_41_triple_steps.cpython-314-pytest-9.0.3.pyc
 delete mode 100644 technical-fundamentals/python/coding/problems/tests/recursion/__pycache__/test_42_robot_in_a_grid.cpython-314-pytest-9.0.3.pyc
 delete mode 100644 technical-fundamentals/python/coding/problems/tests/recursion/__pycache__/test_43_magic_index.cpython-314-pytest-9.0.3.pyc
 delete mode 100644 technical-fundamentals/python/coding/problems/tests/recursion/__pycache__/test_44_power_set.cpython-314-pytest-9.0.3.pyc
 delete mode 100644 technical-fundamentals/python/coding/problems/tests/recursion/__pycache__/test_45_recursive_multiply.cpython-314-pytest-9.0.3.pyc
 delete mode 100644 technical-fundamentals/python/coding/problems/tests/recursion/__pycache__/test_46_towers_of_hanoi.cpython-314-pytest-9.0.3.pyc
 delete mode 100644 technical-fundamentals/python/coding/problems/tests/recursion/__pycache__/test_47_permutations_with_dups.cpython-314-pytest-9.0.3.pyc
 delete mode 100644 technical-fundamentals/python/coding/problems/tests/recursion/__pycache__/test_48_coin_change.cpython-314-pytest-9.0.3.pyc
 delete mode 100644 technical-fundamentals/python/coding/problems/tests/stacks/__pycache__/__init__.cpython-314.pyc
 delete mode 100644 technical-fundamentals/python/coding/problems/tests/stacks/__pycache__/test_21_three_stacks.cpython-314-pytest-9.0.3.pyc
 delete mode 100644 technical-fundamentals/python/coding/problems/tests/stacks/__pycache__/test_22_stack_min.cpython-314-pytest-9.0.3.pyc
 delete mode 100644 technical-fundamentals/python/coding/problems/tests/stacks/__pycache__/test_23_stack_of_plates.cpython-314-pytest-9.0.3.pyc
 delete mode 100644 technical-fundamentals/python/coding/problems/tests/stacks/__pycache__/test_24_queue_via_stacks.cpython-314-pytest-9.0.3.pyc
 delete mode 100644 technical-fundamentals/python/coding/problems/tests/stacks/__pycache__/test_25_sort_stack.cpython-314-pytest-9.0.3.pyc
 delete mode 100644 technical-fundamentals/python/coding/problems/tests/stacks/__pycache__/test_26_animal_shelter.cpython-314-pytest-9.0.3.pyc
 delete mode 100644 technical-fundamentals/python/coding/problems/tests/trees/__pycache__/__init__.cpython-314.pyc
 delete mode 100644 technical-fundamentals/python/coding/problems/tests/trees/__pycache__/test_30_trees.cpython-314-pytest-9.0.3.pyc
 delete mode 100644 technical-fundamentals/python/coding/problems/tests/trees/__pycache__/test_31_has_route_between_nodes.cpython-314-pytest-9.0.3.pyc
 delete mode 100644 technical-fundamentals/python/coding/problems/tests/trees/__pycache__/test_32_minimal_tree.cpython-314-pytest-9.0.3.pyc
 delete mode 100644 technical-fundamentals/python/coding/problems/tests/trees/__pycache__/test_33_list_of_depths.cpython-314-pytest-9.0.3.pyc
 delete mode 100644 technical-fundamentals/python/coding/problems/tests/trees/__pycache__/test_34_check_balanced.cpython-314-pytest-9.0.3.pyc
 delete mode 100644 technical-fundamentals/python/coding/problems/tests/trees/__pycache__/test_35_validate_bst.cpython-314-pytest-9.0.3.pyc
 delete mode 100644 technical-fundamentals/python/coding/problems/tests/trees/__pycache__/test_36_successor.cpython-314-pytest-9.0.3.pyc
 delete mode 100644 technical-fundamentals/python/coding/problems/tests/trees/__pycache__/test_37_build_order.cpython-314-pytest-9.0.3.pyc
 delete mode 100644 technical-fundamentals/python/coding/problems/tests/trees/__pycache__/test_38_first_common_ancestor.cpython-314-pytest-9.0.3.pyc
 delete mode 100644 technical-fundamentals/python/coding/problems/tests/trees/__pycache__/test_39_bst_sequences.cpython-314-pytest-9.0.3.pyc

diff --git a/.gitignore b/.gitignore
index 9fb14505..d88df1db 100644
--- a/.gitignore
+++ b/.gitignore
@@ -3,3 +3,4 @@
 .next
 **/node_modules
 coding-challenges/yarn.lock
+**/__pycache__
diff --git a/technical-fundamentals/python/coding/problems/__pycache__/01_is_unique.cpython-314.pyc b/technical-fundamentals/python/coding/problems/__pycache__/01_is_unique.cpython-314.pyc
deleted file mode 100644
index 7adf4fde93da68d21df5de4402fa5362c2011e04..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 596
zcmX|8J#W-N5S{f!ce&*5F!@jbMGz7Z>4d^M4GL03844r>79>rCwXrwYVDFmUb)xHB
zP(*@~l0U#dIxQs?T~1d-bj<olo;2fmZ)V5q=f{Ko0wDC}-z*>iza6=T_rI7fVNpW}
zYY>t($bAE$w*|vij3>Z_!yHBnV;W$p;Sk<?dtU$&)Yjn*Nl8eKu`@&H9baz;+U)w{
zxFy=Q6*rX<L(jIfQFiV`%6v#{`&6oe8SP%TX*2pxbEPRN*_o!VmHfzKqv>uCe4?2!
zT%Be7d`EGXjHuypDzcd6JExUMSiyy1xu)gFq*BmWCYks^OC?WoUT7NZMwyN(k$tZC
zlX7HxQN)Chh8Z43%DL6X(DyLaa0PARPh9%GeCZxPRvI?NE;RPI!r{iAr$}m`P?AIN
z;lKwdy`zWEP)%@V9Uh?3TWIvr(l%-@(fcmkM~;Sj2XB9(?aJ-4os{XcV5KFocD`?K
zY^bhlbZ@S&aQW=EkFcm=Jn-umzxsm<GG6R`+qcVi#;bQPI$swi9T?o2%tOyti#Yje
mNSdRnkEBs%o9FinnN&G{u5M$){R!>-xNH$Zu6p?O&FnuAZhn6N

diff --git a/technical-fundamentals/python/coding/problems/__pycache__/02_check_permutations.cpython-314.pyc b/technical-fundamentals/python/coding/problems/__pycache__/02_check_permutations.cpython-314.pyc
deleted file mode 100644
index 0cc1569f872095d5720fe684f36c6803dfdc8ea2..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 947
zcmZuw&rcIk5T5t8w9wxHBZ@={O)!nXwuJ)*Vqzp<AVFwCxsW!?cCnT1?)u&?%B=?v
znApI<0|yV9m>3gp{ssOAA{?6arYCNYniy`*+qT50lgxWF-^_k*-pt$E(MS+b_{c@&
z69M=koQ}}8(d<Q|207@59O(x=ZbObHAtkB!1qc=5N0m^Uv$)hC4+T2?9H4~QAgq!y
z$&n3=v?NFWu%(U8Ngzwe>pK;`OL+!0>-w2yJIqK?SK>BveVeAKr-<v{GFerzxj28s
zW%3%=7?%;L>~ML7nU6Kq=5i*T-j*wdt+Abo_H>+SN@-WNHMMM1R7D@(a*UEv)eKwF
zxoqv)Wz&#Vvs5u2$rdv=b*;+fbhfCLHFdjaX{_qlcz|i}32WC47mJEvn22b_A`4+1
zU8sB*mm2(n2$?(=%j?NAvAw(RZ6D`6u!%{aUfvs>0IJtN(a{>nV9`9pVIJu$X+3)f
z(Gv0xLIKv3qnNy&oS`#xYyi!+6v$YlV*@ynLq*<F5}*feLY^R7qRobQsb8@Dmjxpo
zxnvmv7{d7{J+2L`rX_j0BC7sNrrLfS)_e|~0Ef=w{hrJfVEO^TGF|Fv)#OmiH`V4!
zV%89<<*Pu7o(hI}F?2=OUH^`vI~q@QF(1NA^w|xR6<)3?mP=HZJmUfz9Ze(>OuT5f
z_urYZD;V%b#L%cgBO0$Qe2c{PNFx+J3EgO1AJ|)XvDoO2?FSE(daNEi4?r~D4C3PD
zyqs->`}P+PhwBgPi{JaMo%dkmXBfh<H-Y!jx6zYC`Z$(3N~8}n2dl6AXdJ~d$D!;O
zU-sf_EW^bw^7&Te-c0v$ig?w002W5DRdV-i)hs!>c9&g6Omu~dtDH%MkY7Q3LSF7~
D?$W|r

diff --git a/technical-fundamentals/python/coding/problems/__pycache__/03_urlify.cpython-314.pyc b/technical-fundamentals/python/coding/problems/__pycache__/03_urlify.cpython-314.pyc
deleted file mode 100644
index 011401cc138347a7b78da9ad753a608539f74229..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 627
zcmZ8f&ui2`6n>MGZMSCAHXsG@$5K&Pv`(s*J(M2zQq&sg>Ol-KnRTPtNtl^!Sx-55
zkkVog{uBO3OS}l4ylvS-@z(dUir@$D&G+8CH;?&d9=NSlK<KUC=@$m@lY+mn{*bwc
zq=W!AAz+)3ts4leyU?*?>;N*t5}J)R_tBNmhc{OD6F`EwoA81SS-@W7&H{n;kMsJh
zUo@>^x@st4#!7ZrWox5wX$*2Tij1Z~Th)LcYN0g8OnRjGfy&>D*l51v`yY5JjZjCa
zINnwwN+#Thcqr32%C-k%nM5NYO_XU~Ow2HsJkFC;zT<_;-)3T@x&I^_t1KN%9u<?y
z3ByRr+(br%p=#pnWi)*QT?v=4%)AS7r}2!IuW=pCaTjV;h!9ATT9pGNq+!AOunxUj
z0EN}J0@i(n8abp<p9R*#7BwwUu>I=*FTMYAcL17j8>{IBDwM4K(Z2WC|AvuT!p^D@
zNqsC-#bQm9@3-4(rOq!dr#3LC@4}IkFm0`sz3(meGn-y>&h69g)bY;6+4Ga$563&(
zKj~dG!CjlJg5#A>75$cH9abNrTny^WV!+DoC{M<j*i-aj=(#kN&uqrnrHd-nwO98v
BgCGC^

diff --git a/technical-fundamentals/python/coding/problems/__pycache__/04_palindrome_permutation.cpython-314.pyc b/technical-fundamentals/python/coding/problems/__pycache__/04_palindrome_permutation.cpython-314.pyc
deleted file mode 100644
index 5c284c07429e0806184920963b3e9179a3726ffd..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 795
zcmZuuOK;Oa5T3O|UwJelg%l_#DpI8Y#fj8IkfI)mpa>NUQY5NauDvA&+iP~6RJr-U
zq2VEN<iL>&|AqsH;9ih8^_D7!iW{>IDMDhTnVoOH*_qWhH*?tqKohIKoFfI`rvy_&
zoY?q09ueqJ1f3MY&4-{X*P*Oh1PSTVQs^rBxPl>qCbX2=YXBSXR^Sn76P@fLGcjG+
zopuK;>2)k|Ohi1xY1rX@S&3B<@;J4}m|G_C%s%6u845XWHSTIp1m!}*8>cI@ZO&d$
zD->F_QhBL4en@%Op$F@nns!eMsnzx!%XHWGJHBmt)DKNpXhAP*Ghefq?fB2NfU`Z9
zdP1vg7=h_JzRj6Ojev5m6XF!+-wt|l#xP9ZXLvykgG=c$=;AVl2u>kOmQQ5(WR2wU
z*-p?HSxB^!iL^7VJ|c)fgMhRkP@0g3yLEs-ZK~T-U6Tisu<<9CyiRIQr|NF40PIxn
z;0rr1)z+1r!Wz~#l@_^`{o5c=wyIcJn42)gf0#{xdAOD^wHp9(zsIs5CZ)%y|2dZ(
zP+m@P`S*CXZHl&M2Jx)LI#TYKSVA&urBaE{%aV)#SCJQxOhkKzNd&`OK57hei&5h!
zn>!@KO!h;g-*|fu({yH_zN>xDEMfL7ePwv*>S3dQf0!u@UcG<trtu?R94wrnlLF)x
zM@xXL*{^?16?q!_KP;1E;1@{X<Y#krkJ%lUZt@FQB6SvWlOvT7a=MIrOKN`u)JU-*

diff --git a/technical-fundamentals/python/coding/problems/__pycache__/05_one_away.cpython-314.pyc b/technical-fundamentals/python/coding/problems/__pycache__/05_one_away.cpython-314.pyc
deleted file mode 100644
index e378d5915a2f6ad7b0319df6fb96ae7c55d5a97f..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 1207
zcma)5&2Q6K5T9qqaX*sQ36$_r2umcSh!(d6mVgilA$kCTAX}O}RE^xkZ4HiX-gDZG
zgdm3=!befGTUI$NH!j>b@elAPfRK6Wq0(~M8&wa88}r<{WN(Z#Z$3RUzscmpK(Y^z
z*s*WcTN&VAVMHYDC|hY%noxuc6iEhb&4;3tgS=cJ7!WKdj*Jyx>jFMan1)%YumVs;
z-!R-Ji=;?qFtSZWsY{n<qE4X8SU2{cu(`y>ktcYZntq)+d5O!+r#v?2x^|xM_`FMN
zhR;O*V|-D+!%WI_^jJ$wzeU}<X2oav_}JJz-Ew@BE?MUCC^e00L-)<fqGMGIdvw0;
zRE?VH_=e4Nui-Dcj$U!Amb0LH)Sa`<8q>$llwHRx8_P!Hq}Skya@lYk*Ef8#T&Dfl
zT}5WU;M0V!kSD24@vL3>BE&zxh2qsz=-k32sO+LeLqQI=_6Bh@p+pM5M>{J*4rZe5
z;yzFB=$_Q&CA(g^lncMTB=$WEUTj9x4QX16vNV`H0pKYmW#nKK1t<-5TZLtSh45Fq
zz8_#ZHVcI{oGB*iX7K`Y!be7uKfd>3*GB<*;RxOc&MYv6RLYHn*R^d$Gt82(Uf4lY
z!?{I$yq{s1B3^t7JoQEl-#A+8|B-Ydk4N<)iP$DWY-Tr_Qhho$vNMkm-LWpD*`G#w
z`UldyG&Px*xon#bSE%7Em|QmISiXnivVe*`@Hhs`c*)yxf-6;Pex7k+afQ_k+vf6|
zwZM8X_4x6lAyKh2-fywpv!faGgje<sl_msg@5&#a2KRhUYVGvXQgd=WQa04&2Q?FD
zsg|;y+SgwC`*7=WFqm4ccchof^M}En{hjf(bNtZJKpX0$UiAH`Z1zGryV(cY-p^`Z
z>(|vw@6|&c<Aa+0qzz%Ul}CY=ZYjZl_E_H7(OU9GBH6sUo=mTuYS;fd|1o)_MS^~9
zwa{jrJ1@_^c<`}57Yy!g-+$KNnc*OjYTsVH_T(zI8pv)YAfeF&;<%Y7A+XmFn%l5@
eF4Wv=-8L`M1DGN%o{4pQkqIGR2k;LS=6(l-`0{`N

diff --git a/technical-fundamentals/python/coding/problems/__pycache__/06_string_compression.cpython-314.pyc b/technical-fundamentals/python/coding/problems/__pycache__/06_string_compression.cpython-314.pyc
deleted file mode 100644
index bf60ad65a3371a6891c22ef6e1b0a6fd8d5ee6d2..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 1034
zcmb7D&1(};5TBRbq-nGHXv7Ar4Yq+wFm+QXrGg(+Fa@ik0aFhlVcl%g)ns>lZ_`q|
zEa)Lr3xQTB=+TS+gMWsRWf2tg(p#m6;>~&6EVk&yfq64;W_D)YZ)Ptg;v;~>rhe%Y
z0>F2E2`DsB4%4VOP=*YYNd{Ue8_J;^<OP+WgEJ=)88g6P5f29{Pzx=*1Zbe`JUk$4
zq)e*lIi_;xk1qSU_IWjrFfT$iyF-mU@dRd56p>YvwiTQ4LQ@`<A2N+H87=xclkZdW
ziKg02o-G!i%DQ1|bY0grW~in#Hf38=*9=`%S~II1qoK4l!&X{Mwl?iG(~woOp&L!v
zqUPh4)@E{XzK#{qR9DTmMK#8B)3|JHdQ!cv7=~#pwpOpxVeEr5JBNn@N027zpZs{2
zJK*Ad&c7X^7kq@c!YP96BXk>|!V$XYn*o|WMit0GH9!-+a|7KXh$R$wwE<b78nJ{j
zvBWCR=TnXR>)W}(3{z0L24IC(!YA`oLJN;@LK2@)MW~TNJjjNz!tyx4%FSvxuvLVh
zqe5UpdFmVSbpGQ$mv3;qvj3gy#Cyb`a)m5>40ej+RS|IyL;JiR4;RuCTAJa7sbVxW
z%HhsOsK|X`wAYzORBuQ%JA6yLh+?n}ltgDda{2-%8s*XHzt@1CMTbB29aJ3n8k5{)
zsvG?wC41ym$+_i5hr5&8qO<5GlFpJFPdcS9@pNx?SKXW3S^XTJ=n^+3ZO`>)Ute*h
zGrecqcea+kNw_q7&9{aA*mPf-?v~ut=o_)S=#FK!mVU+|kv&L2IJTSXHFpaAM7A$x
zG40SucmBomp7v>I-0#7SjXHNJ|BvtGiQni4@UO?OiC%4+jZRCuPBR$7mx}S&1A!27
Kl*WbiV}Apm^v$*a

diff --git a/technical-fundamentals/python/coding/problems/__pycache__/07_rotate_matrix.cpython-314.pyc b/technical-fundamentals/python/coding/problems/__pycache__/07_rotate_matrix.cpython-314.pyc
deleted file mode 100644
index 987da6b4277f56f20005233bce6708d3f1064793..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 1411
zcma)6%}*0S6o0eZu6(oxDvC-Y7AT<+Tq+nn7^5)~i9n#yHb$VX?P3?(?J_$>x%J?o
z#?<t(Ne?#Z#e@HdcVkep;b7v48>S(|#Di~kX>2czubJ8R@tgNG^Lpj9zXy=ak>A=M
z0pKSWnk1eujoZi+VI5**9v%=zhGC81Pnf*egaWkkOpFPG5EBO>+s8aH&nQH^2OJt9
zwr4>zS&E>*7bg!c9;z{cTM^>0F5G+rkVah)R!D}#$SPV~iU~1M7SN&R0Mi9q$|;O$
zuWgB{tU&c8j36yKD$Z@>DcVgQX~fRSk4=@DGHSGKQ(mU|O*O?#IXXT4Qr2{)(rrzB
zHAPh=y(2R<mC?17lAYQp=xHUV>P*R+va!Q5d0kHB)0+N5Hfa8NR?V66^o=CVGli*1
zH=V1-j_pe(6<v3=N!p7k^x-mj%ZhLey(IjLZy&}F`KSKKks4?Pr#qbCB;j(pa}Db)
z!fLZ?*r(YO-XN>ZtAaRL7bbaUPN<3LgSjIBL->bGgyO=abNMcGowQ1`CqD4pE}jz;
zZI>MvTd&*jB--Repw&~m-?nq!1nHDRD>iZFKYdE*Q~W<H#%_7Q#;JtSu8E7|*qX$h
z_G&v-=irw+AzCALs>$*6tP`TuQ(WNqhu;CZ;SxMNcE2%#b0SbLnwBDhEoN2S_EJTE
zp+>r>gj$>EHqmUdX?r&`YBF0g)l^<j+g_H@XqwMYfwGL*h1l`SE>ZquY=7Hxr-P_-
zUiW8Yim>0+Tbg^<TfDpP4^*NR#hQKpv_$s%&sDanN-bOu)gs^e$4Yni1}<9jRmEB;
z-QPPqWId^F)y#UdR@gloF3q8_x>B1#-F0iR9{M<1S3ZV!2PPaWy17>;wfojuJ?f%|
zLX~KFzM{Nc*c%>mSu0fyS?U*GaBnnHiCQz2E$e!Du^Ot4@+`jiE<4D7`merVqaOm{
zh6txGP#>1E6!F>;+c9w1DIYOg#QzD(+u@Y_2^^H$lCE31e7cZTZ_^>P^U*YexE+dw
bkfR<T=YMqjOX<o?St}10rQ-k&y>t36Dk})t

diff --git a/technical-fundamentals/python/coding/problems/__pycache__/08_zero_matrix.cpython-314.pyc b/technical-fundamentals/python/coding/problems/__pycache__/08_zero_matrix.cpython-314.pyc
deleted file mode 100644
index 2357e3f243cda72bb458e976080b15d6a572e305..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 1678
zcmZ`(-D?|15TCs}U93bOmOq-0x|L!DIm*}B!~}<yKua+-c1&_KY9Abli*&LtmhR-e
zvs1O9=phe+BDf+K1Wh2X{eOy34?h%I2zg6Tis@Tt?@p1<vFF&^+1c6s&2M&gug0RM
z0mYpCPy3Sx_?ry|f@4?ucd%<f9%QltUlWTY;UU3~yLQ3%z;0Bxc$qs3GJh5-<CY)`
zX~>3NGuJF}gf-2yiUbF&F%hsasQzXAH6RChZs{3732ifQpKKACY~YM1GAHvAhZ_p7
zIkY%pRk5h{y(3c9+NJtBB8Ycg6Vu8D#d(t<%{trC15>4@gcfbjl<raEv0AiDX<>eT
zTheq(rF)wC<T_QAQeCpt;+C!zmCE(<u3l2As%|M2Q>xXiEkl=zMoH5*r5ZIJRn)2}
z%`X*xP^nSyg1J$vJCQ;`(RIU8EVWReXD|SkXOktY0f%sbeDaq4o{Mi-_j1u4^>G&5
z+%Sd77&bRI{~+52$WSBLxQ#*XFk6eho`j9Tfx$+|U5&rt{J?J<mWu#2{y6V%`O#w>
ztQhpT@=IJP1if;?=$bq%eFw1Vp55ws#OFPWcbYP(k(_YE!sQ{jV;(XXd7f25psaEN
zv#)*y5Qa}-RrUHIk32b+H>(pAjJ_P?J?bBfV8D2BxE4{5G7m=Qvx=~)J<7<7{6jt`
zX6`oQAB@RozwEQ$^7<T^^XNfIV#vd6jOHR3>3ep5<zQywjNOSDPxx5ed#voqSjX%h
zV|hQy$2;ZKac^%K?=)*!e)*gAEboMB6tAQcqKdw$I($Xdvmq)XRVQ55sA(0b@x+OE
zYSF0dR&|GH4tZ>{%Fm=wD7$dZnUQ-*r_thG!z;+V0lo3*#!7GUTx0D(2sbm&?jA%Z
z_HWvI?a#W=WRn~uKH4`sw_e<C|I|%nnqTzd)2(_Z(R$k1>BdvN$*B(6ztu}!vT+Yj
zPtVzFy=2N3e+_po{t|Ijdxs6$k$xN|=HBuUOTC+d*rdI%U+iSs+ui7_i)8OSPj|{M
zwBK%Y6WIXPABZ)wXMEaLM#C6PAwn1?t}ul3VGPC+e)umh4heib(_FR}S}V5l^BOu%
z%)L4_>ASUm>?YEP%UnE%J~~`NudykLH4W?8kRw|48oqm!y)zDv=R?{1<fip^aJ{^w
wk9}S>O1l;H4#gM1edo;?RNnA}kbh4DIrmpM+AP^OTUsmG5D!Is0o~RA18{aW$p8QV

diff --git a/technical-fundamentals/python/coding/problems/__pycache__/09_string_rotation.cpython-314.pyc b/technical-fundamentals/python/coding/problems/__pycache__/09_string_rotation.cpython-314.pyc
deleted file mode 100644
index 44cbf53c572bf136ddcef4cc2eac59d204eee323..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 644
zcmZ8eziSjx5T3Vto}zb`NQ8^v4~!64H1{qx8i>}h3A$ixLYBSVm)z>!d&j)Dk?Xdw
zv9qxgD;vQ-#xiVcl`e8fuybbD6LDZ>zW42WGvCbK>vb;!nO*ypeG&lQ`LHnW518K~
zP{IL(;wkJ1CvHRN^&#~8kS{wgY~6+6!YN-4MAgY`WQ&n?nCYX0N&-7uo7^X#Z&N5?
z4-ULXZvj%`ZoqRf7NOXuFO7xXKiJ=2NCD|nv(_n}E6;9{Kd9QMT!A|9Dxca`t&uS~
zDQO=XoW#y@|Fz1<7gnK_#AL@-K11_LCC<vt;qbN0v{QJTsW%&_;&djRO2#@%;(X(<
z&}lqT+Qqq*)0rC^EfbT{Y;uZbl&guA!>y<pH$vm6ywQW{tm;HjtThuVim*!}c+>U{
zg%Zv|i0eN%eDu#aeO{^4*K0L7r%RCh9hwfjxO#c31WI@*_QZWc3)><<ixInDAn=ek
zjTb3cF0sCj9ZJ>Ge<JZJv9+ciff7!xbl;CY^xr-H)>=iTb_2h<*$g{a3_B=XmfJy7
t$|6gu>)<jYe$_O)v^_Ctk*g=TLLC1ByF}s47ef5(fp~b{rm5=(zX2n~kbVFF

diff --git a/technical-fundamentals/python/coding/problems/__pycache__/11_remove_dups.cpython-314.pyc b/technical-fundamentals/python/coding/problems/__pycache__/11_remove_dups.cpython-314.pyc
deleted file mode 100644
index 5844244d9a2b727418b0292cc401cd7e15607bfd..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 1318
zcmbVMO>Y!O5UrlC-Sro?z&L;v0~WScU<L~$B7|}Q2_r>L7#TRAb!(XI#RIcFOLwnf
zIjxikaeyet`~`joe*kV|E>V;dH=_mlN>$G+Add8*rmCyw)$3O^b9!ca0&u-r{Fv4q
zfd45Nub_0;=sr3_*oKH*hYe=f68X+`XTvq_hG)DD-}p<=a!)|yUSQ>0CYT3|y#<K;
zme&f-938^~TyU#1wWtx*@I-w9ve}H8dK4@}bK)JPo2;0OrOZui(p>7MThz7&J#i~m
zMeUl9LZwMj|FuWSI4jsz@&zBDD!@i7xI2Uv7#4wXwx^97`H_Pq-KwM)dB%?zmJJGT
zGjEH{gl<sX0zC8)jE#<4pj)u*{PYJv8}}CB2HRl~i=4=fywE`i{~c-wg})nTeW7aP
zdr~|$PY#ZW-dUv@ceYxqt(SDgpp&a^Y&6w7Sv&}DYN2$9JL#?te^dE=kr*AWpF8&;
zOr;TOHx-Z8l!)7d(1>J5rb(Qwb^5X$cZD=@ro-OA?Bp^`@^&ikg*}zu%|sU=*0~bh
zd{^*xzo*ak2E`QTmA-=WVvcy7{d#K#Dd}TqhOiHgf8;%xzvDf6yk5Oz!x5$-snjMP
zNC1o*qaV>3!tGf}yLR0^F2}M$1k3P}Z8jY>g*i2i20QF&k#)Z8XaZhYSy8k2Eb5%6
zGBwC`y5d@fmM5VM;qCm<=M!%a{qSc)9VA4@0+)dEv=I=BM6D2Ig7a?P?q}qq77zPz
zR%H%w-bs}<St^ChIado*f1Yzq!<g{c7?s}b8=)~r<!v>~QZ*<fLs!y7>nZFzDA|Z~
zD-Tlo`^L<%W9F$zL@2x+oP#HGpGT{jtX2^yVfsp1YE7mN5EDCKCB-?66&cb<FQTCi
zGuC)d=Jny#J^MU=)y9^x{U-3BT?B=lVI%rM3~ehFsXMN>gubm;HE!~&!BZzOY3us-
z<$t_-sfle*gPPLmBYA9!qV5-g8T4?Fm4|_%cNA5%-&UzL0e;hjqJFvT?9b{HW{Iyp
xk7mzhjD4H|w)`)wy@9p=yvb)*e*b02J_Ig1^6cVY>n|>S0Ce}K#%fq{p8$TR8;Sq`

diff --git a/technical-fundamentals/python/coding/problems/__pycache__/12_kth_to_last.cpython-314.pyc b/technical-fundamentals/python/coding/problems/__pycache__/12_kth_to_last.cpython-314.pyc
deleted file mode 100644
index 9fc4a1bcb08418afbc91ec6959f34974f20a1bc5..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 1337
zcmZ`&OK%)S5U!rr?)s6~N-UEQVG~ET7O*FYB7p+p!U0D@21ZVDh}NyiY;Sh(xM$Pd
z>##nJ1VT9g%8?`2@H_Yc;THOW5U1Q6Z6aT(>e+>Wls;6~qvxxy9`o+0`5D0T>xGy3
zFAU%>GNvc06*lgnQo$Z1>;`Nz!&XT5Zg|_i@wWpLY=<UXfsX$+B>pu-p<|*YKs#85
zB<uv8=)Lo`pX4>a)=eXcFy2^(V!<?%<{GqH&nVPpb~cr=G^xo;soTD7?2ZQFR;p~{
zQz3=QGu!-pK*6-IY&Wa%YB>RC<8`zv=zw7f7;kUJ_(_;}n9!$$1v5bsm@r|OHnPD^
z*%dn(v7b}`0qO|G#;XqK7VLQ+d<)P;-v#)R^;yCaFY%Kg_7Ea`=HW9N9;U@ms0QhQ
z6knU8GgG2>HYmrP-OfhmF_jqgN_CJLP5Ca`{rIL9O2_EQ4|V*7D!&q$(eahbm-pjb
z8letz@nBPlv^$E8$oewR(qgkWl-=||NRt*i9*j)ClyO#eb9pZwsPb+h4iMrh-#2}3
zN?xSeYz;<sj`K->1?P5=cx}Dvnng<bO%xTJfES*7PU5HZn64)q*PS`WFl3W%lMd7X
zv|Ho1P^sYdf+Vjyw^!w~t&qSPJZ3v>Pt9RW&7;5x2U--pe?6Lj*Vot80^YXCc`kE<
zT<0fTYt!*0lnS0Mo&SF3>Df1aY^gJZ=sDmTaETldp-Ai%qReo9P<Dp}>DY_=!?c)0
zPIKPNl{Q5#g)BK&%anhKb4|;b@zfZV-yIsEF?I@LE}LViT4a)-e@YXr@8HD4mW`=z
z^+O8(XUpg>!&=$+5-JtEe#>xqqu9qyYbYw)27O$GqsC;XEZes}u8ED5FheDe7XMkh
z$%~Go+h*!CeqAqJO?we-MS@zbFQTBSGuC=e;?cchx_(}B*OPZXbY53XMgyN78n3H^
z3aZ?Y74^N&>ZujdS5avCYC722R~A!I2ONhGl?r|jnl8;wyF~-*4Y4j9n4-<Fkr@qe
z$yI=cqW6mOy8o`81A+Z-K(_f&J@t>(21bdo-a>KgGsa#vfvx=ko4>*4pTX?IPrmuA
aVlN_}oqPEHqbomLe*vhT%wZ=Sr@sN{AR|8j

diff --git a/technical-fundamentals/python/coding/problems/__pycache__/13_delete_middle_node.cpython-314.pyc b/technical-fundamentals/python/coding/problems/__pycache__/13_delete_middle_node.cpython-314.pyc
deleted file mode 100644
index 9e541d1d5a091f23f6a8c94d2834ceefaceb8cc1..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 1358
zcmZ`&OK%)S5U!rr?)s6~B*r8}*ol#?71)y~k%%J1g#)&P42(>Ch}NyiOfMdo?OD2e
zP1dK8Kqv=59P<})<0o+B7;a%M2yx2I(I)bhs-9UwK=h%y9z9=u^_aKL%+COxUoJh*
zes%!<Bx8DlT49quDkU61#CBkt8MZ>Yv*T>L#@+Uex9uB$1$ypfh};{j{>lVPfVQ^`
zk>B%r!P^(7umCsQ=1nUKFy2~*e8IG%_8N3MPbk!7)od(fVPcaNQg_{|wKpD$+p(%z
z9|$Q_mQ?MJh7^qRitQyYumKuyHd#k+2|X|@0^=Mk7&r1G2NSxKFlWY#JmW_U(*~8d
zTclz)A@)rL;GvFSY_e*BZo`3d^BaH^eV5=9cE}<YIguNAp@R_q6YL*U{!yHdglduQ
zNpa5{pPLfBvq3rT?DaN!52?hUU#LNBH08Tesqj-Rln&989qI66ReUZIqr+=guYM6`
z(g<~wiLW-5h|_UsL~<yzB+fVcBbmknAx)g?a5y%Hg$$D-&E#j{P!)G`F+hmxJQcYx
zf)BDZ%>|dpV{16B<~VQKEI6+giQd*fU5m&}zmB4WQ*itXPf0w8Pw0BIam$($3`5d1
zophi+pxv3gfl3Mc3zEF{?61mccOil`c*u6Uj+(=mnn!_y_O!_RFFcxn*Vot80^U`d
z^Gs$2xz0CSYt!;1loB2<UHoq5@%h(&=%{mq=vd$yaETlNp-5~QqRenUDAEyjgi|lR
z9L0GPIm>xJQ`+R26tdu4EmQs_&Nc01!ee7pc6Vfi#@HE**=&}j>X1o-IBTNyEu1>o
zvI+IAen{b$mW_Tktd&jPM5ToPUpCy~AarrzT51-bR^B0Q#Br-xt*SjNbVff$<>Jy*
zff8n<<niL)OV~W@S=L>q&LT*?f;D^Ur6Tbv1+Ji=;WO5GO5(x(30*(A_Ih-4$9io|
z3C(?aXv(%6s;jiKR@DAFtD{y(UqzwmtLc1S`R|%4>W8J`qf)|eUfX8d?RIE<{SlUj
z<5RRJRba+L+<fJsq3FG$^!8`0r$S)=8dueRx88yG)CNY0xZXl>;xfjbp9i+~J8b?6
jn}2w-_uv2e!;(D<Tz299J3n6g{?;=<^>hv!VmbW<O!6!O

diff --git a/technical-fundamentals/python/coding/problems/__pycache__/14_partition.cpython-314.pyc b/technical-fundamentals/python/coding/problems/__pycache__/14_partition.cpython-314.pyc
deleted file mode 100644
index 29322c4ecdcfb09898a27ffb9b668780856e24fb..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 1325
zcmZ`(OHUj}5U!rr?((p~HpV8F!NCEo92k(05?NNHD2IR)ZJZIY57sgo&-R9~hn`J$
zFJ^rjDUszvV&#~h5dKRJ<mSvJigMxxS`f#is%O{Ok=zp1_2~KPtH*NZ!uSZ_`TfRe
z@~;K(4;jPbl?v;(QORKo0=5C`OtV?itqp74*7mxiopo2cv(U6}L13@3@+<940ou+q
z1a8x5dLPdWVFA|c!JA6pVZ1U8>4dHZ)p@Ab4k=V;#b_i%rX!tXLe=e}vf1nK2azl)
zUvj}^5*O94I~0u4f^Ej<*Z>1?)?Ywx4o%Q30BvneYCCWP3lrLuFlE{a9PI`S(|U!|
z$XdJ+6Z=60;Gm9RtUqUf9>A9M>5l*{^xc4O*ftATU<G#I_!dIAhuA+T+}$Yca#<nW
z5qwWSzdR)RXpwR}+H5X1_o+m$oyna@E6Vp_k@(*#E|rg-WLNq3W%h)}TKTIhD^LAI
zXfAgX{%lF|sMYf|kGDk<N9j_#D_YSG7dlFn-|6Y?O!#ruO2l`5M`n*xzJm~JVJDJ0
zp?)oQdc{~64!X<3u$UxP%Wu0bAtChviX6_sa<3ng_%%AB>tOM&G5Z*Xc+hLofyzg_
z*1w5L4i6^;dChq^Cx%Uh0OnzzHR_fe!<ZaLf%A0~Puu4nMZgOS3vvSQq8f&YNHlUC
zA8;*A!;?^Qcs(`q)5z;9*Iw1+WkR$Ja0xg?4v$a-b_!8O!f+>RbyL!@7vFcIbP%~1
zhV4WuohE{dEDYr|<(~>eMXMNxk=8PK+|^uR>;lG2Hp5cZ$Rsg|e~M_mfHMnQ)~CLe
z4=Mc4j?r%nYi0f0sO0ee9i!FtZCX`1icbq?8yDgE<eS|ZtX8vNd*$+ZlIyM%hGm_}
zi}+EwX(d}CDM?U;Y90j*o3Yw4iGwR29nt;UEpr{Ld~V#Ph?oXFJTz9rp9;y%a3%G-
zOl!$m(&tbp`f51P+M9Khl-W>lQOV&?r)rWk>NOfuyNfm8m?Y+a!qdGDF1B>gkn~<s
zR#R@-eFFR6Sc>Ysa@L<o`hP%t)iR1Bn=y8J71;b=u=EEk{q2mt{NjhNa(3d`?E1@3
Sep&tb?g^lJHimsLoc;qGULCgp

diff --git a/technical-fundamentals/python/coding/problems/__pycache__/15_sum_lists.cpython-314.pyc b/technical-fundamentals/python/coding/problems/__pycache__/15_sum_lists.cpython-314.pyc
deleted file mode 100644
index 1496bd267fe3663e840a21193d6e10c2649257ba..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 1230
zcmaJ=OHUL*5U!pVyF8Z&B7zD+mTU|R7)>-WoZ*5xiE=Q|8D?i?bhc;h?nU9W2jj_j
z_Al@g{1tj6lbD!z;<lR&*{fAEyZAU*$y9$;)m`toGd?y9NMGkKqAv!(PZ9=X<$!fJ
z5wu_*Jhly6OtV{rjcsGg)aEUihDGqq8St!o=z&OEo{h3I193^)-p~?M3g={~uyn*1
zBGJB%5}{BmJZ=#5<ACe~GIPMXWdtqQ1I;|p#{PshJ=-(TH^z%gF~dj}Mqn7hNv)lv
z8tw!P-_S=yC7?6bT|m%+=df=)cn?rT-8?*Hhs<N1;hCQ08tB44rvg&@$d8+0YDPk*
zmI&YJlhPo|7b_HFW$%<qacYUI`&v=3+iB!JQ=wEYYN8|MK9R|*Fwn}~SYLnbqN`9I
zMd9038T!>@SBJr&hyp)etu;l}uZKeWv2q*7`Y;i0kW?e_(rw7(AP(#3;yzc+I*%iz
z)mq~?9p${=#gOxKl2TgxQ&qx*)Ld3^4-9*@L+o?VrsG@XVJ3Fb3_-uqgn?>Dx!Apl
zpar`nLE4OV7sQ~W;K34{vYm<{i)fQ0$SP)PsW7hn)+lmZE|=vvo@s&eNJJWQ9qZ?s
zi&>tdc%ubp)7L)^pG{r+RFsqC(a0R<4zG~HAuj?ug<gg^uP4=JOc;Cdrs>Ch%LM1O
zNGcsiA`}Vda+=~#bFOIR0`6-qql2an71}6r7A?zCIwTUCz)z9!1N01RS(o~jUnKKi
z3q}g8m35a9{Aa-o&+-h{q$QIDyqelH&5e`s%gv(B?B(jasUt((lp;&9!sHmf$k!}S
zl`@pXs616h)`A{btk@xTHZt2b@%(|Ojc3~dXR0%VC@Ui9|E2gU|5391sgPDSTuJ@T
zBOCGtVOj`9uLc7xUaq5DM0J+M5P}wT3Sj49c5q}ks9F;X!9hvdh}6-?4P0$$p^!J6
r-v2X+wD2e&@1|TvD{Y>dN7gnOV;5I}Eq#Z%o?|jxY-GLBL1n)HCAA5y

diff --git a/technical-fundamentals/python/coding/problems/__pycache__/16_sum_lists_forward_order.cpython-314.pyc b/technical-fundamentals/python/coding/problems/__pycache__/16_sum_lists_forward_order.cpython-314.pyc
deleted file mode 100644
index 8a7381e6516b4e20e0cb0cfcaf017862807037cf..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 1258
zcmaJ=OHUL*5U!pV%X?J_A}Anc&BnlhF-8-^87`=kC<g<bVYXLBXM5J}UJy=uFrJKO
z{{sI;Z)6e^6HnYA8?slcW_EogTFF#@Rn=YZxidC81V~?IFXGD<z;_b*<P?B)))2H|
z2LiSM>&&n@!q$ehZX0_JCSd^rdkO;Q9(o`$PT->KO+ivNZZNP2)zT>$sw^80rA$p|
z;#6uBOOKlb!z3bmpX>s#P6a_5w!yFfjI}dj?7$5y^o{Y7a>6i@gAo`;@G@sJt%=Qu
z;T!shs04JzI`atH@Emrm2k!uCsGEhSY>x#jumU@9d<$K;r&K`Z?uSWBWOgh~=1B3@
z9F_Z7zPL>>Zf_q`DPBEQjnHTcb~8KhpJ}1AkD7R2`%hH*N<>Ect1Bz7eRL(%ek=}_
zln85wz7f%$jH57Fs<&h<YzS$>MElJ{vzJOgN^7xv={Hrnn}`OwxX*Q~!IM}U%`xaf
zsA@b_HKCT9huH|{y`BorvrClV^6#oqOi$0`^>@K?r_YIfiq7cxTz!~}9W+DKYdc|}
zPM|#4xq+Y!TV+YwoVMm=zrPT`A{?{Ls-*_eriPJK?aa|4ssGYwa$KoY)EJ&wiSt;-
z26G+l<ywe&o+Egp4JVV=J`9~qT>UtxE|EtocU(BULJE((NbDPW8REQ=)>;W+?8Tc_
znDi{;oY!NeO%h8XQ_j^S#h>I{(*j03G)Bd{Eh9AAC~_Vx&r*3L5+l7P_8z(xwyZ;a
zD=w1xk98vj*2+4!5d3G|tiTB@-=>vQCA^xsG~3mqv7dWJo!KtbcQa23(^4`|vC355
zsC?;)RL9YSB6b-+T|w4{E;wxPoY=|m^qGz4H#}WD&phxZ&Ib_XMMS-S7GD*=O`bm$
z($0sgsNY3oOI;^S3!&*%f1p$USWdNom-3tj5VYaE1a1*@69<T6tGBQ$9Gjy3$UJk{
y#I;ur3Pt<r{a<s*N{@<Ruc=#Tr7q}MWM?*G?4k^8@hi-9J)7a0BkPXz>-+(yDio^#

diff --git a/technical-fundamentals/python/coding/problems/__pycache__/17_palindrome.cpython-314.pyc b/technical-fundamentals/python/coding/problems/__pycache__/17_palindrome.cpython-314.pyc
deleted file mode 100644
index 6ded46b8a8dc918c8803ae2fd61b214380c10f27..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 1310
zcmbtUOHUL*5U!rr?($HG5*`vkNgx}A(S!s;j290=Vo)cD2eM3t*<Kl)?OA(z(dD#>
z#$ckxqd!6Z4aSSk#TZZAFpJ@8RnMZvt9_`hN6%MZS5?oYQ~f=F>(ltp=oJI_PR7Y{
za)otjsI*}NJhlu=OtA^ljb&rWROXVUtR-976HqZPfM?Dl3N7Uf0ov9ucy`6AIG4wA
zKgoGB*HyuDFkTpjct91s;uMri2NWu^tTzxMQGtpQk(SM@u-a<ywLoTtTU>A%g<0`V
zgMvYvvDGlg%Vigwb*9m7Lj@G`Kp7i7%Jgi{z=S3xjG3}LOW7X7v`%KNBvrl=68r8A
zz(O6tSZ7iLt-*$I?FB#;edBPCZ848|hG%+~YaoPuVBoRL-VWj>mj%)-!Jny}GbcpX
zXDG+|YGtOfM^|)eiL3`IrF<8&NACTU%hW|rw4J(lW%7uJDs``3x$@YJgyM2L;!kHK
z52`I!@o-B-VGz&OnxY!ixllozx{a3FN`xCG)kr*a8#399c^x4Z{6-K*qAHU*pKG+T
zKHu+_m-~J;NVMkucJ(5o^c;#d9D`wx{vh!_IHYZVW>K3R3`5v0Ht9h3N4wNHk4hUJ
z3<&b-^<Yw*R24j!f<3lUHe?^hWIqaQu$A(-_Q#VF@bvVw9Kby*`hFxLg<Si)Tys<N
zB$PIM9vXYy^ZD$^+mbv(h=vBv0f)%p5Q@N3Axe+$*OO{9CLL?>q#4BB$Z6lNMKV=b
zEiMw@m&25Q$oEs4#n2CwlF?>U@f2gHFs8F<ma;@933^f~(RvBT29~Ttb;}P@_<x2>
z(v>r73#VXb@b_SK=c<x9lB=c^nYEcDvF2B1@-)%WLzeR#L|c-e+Wu}cW2GN}Vt=H3
zNc)GXHZ^U{7!T`3NZ1|Lq5nf$w^LGuPtr}GuG4j!*B_;Sjh~#tuug32&%anjonob2
zqPEnU$RFDxssEXyS`D0JX`vzMyri7^aplz}uz%W+6|d*Ly&>rbKy1@F6o)2b>}L_!
m)K{4O2(#a;-rbweZ@1ZzW3tiRg?CrqEFJ->$9;Hv&FL35<s3@@

diff --git a/technical-fundamentals/python/coding/problems/__pycache__/18_intersection.cpython-314.pyc b/technical-fundamentals/python/coding/problems/__pycache__/18_intersection.cpython-314.pyc
deleted file mode 100644
index 29933b8bef200b893776a2e26823495fddb3e257..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 1336
zcmZ`&OHUj}5U!rr?!tm01Q9R_Bt)Q93}YfoMpopD55bZ}k`^`xw2X$?-Z06~v+nLC
zSxzH4vV3r&9Q_ykZ=8cAG?&E6i5qA^TvIi(8<R-sLv=l7zWVCXpO24?0G_w=m+`s<
z@D~}w<CO~Qw^7Mp4>)@Wo6N8U(yfQqrfuv^$2gm=aTlOze*)aT!^*#mHw|bzGr--Z
z)AVl54PgQ9*n@8>+{1Wf29gO=<<%u<)J`eXVEJe$Wokkbr&2fUyt3Wvh$o@SD_;pI
zR2=2iuR9bBlbmfw@38>};H<xl-VB;x7zbnR)s4+vZec>35+=+z+%Ya^nAXdkt+XY!
zB4R(N036g2jP(}_peL|rZTt+-Lf<@m%MKW4+~PKOd<!AmQ|uq)?opU@g{qM5Nb!?7
zo*EL}U7;Mi+s&2cYbw!er|K{?n(}>`C;nqCl=jgRA8G#^m3}WGqy6>Uw}0?sX@ok8
z#gD5>gsq-$M06nIC`?w{UD*l`g*0KJ{Z7vuq|%SlRxH2sJ1X5z#34d#1O<RbKy2As
zr<d1*V9;O@1o<QpTf6QWLr(f8iVUv6a%ay;yb90gdb4t`F#8yWXwYubfjWS8t^YA9
z8SG3*@)l=jQ4aeG9G2iU+iF;<jxj~KaKw%lN&CG=6Y%o#vYNm<uLf8`Y>?~NfNN<M
zJP9R(lj*saBPSnz^lME`5u#N9mw?mc@CZd>vk+w@2oBR$Hz6H+@w6KzgUF2_Xva#M
zB$h&^L7-+R|8x*&+QujdjZyJ_*9eWVaf}t&3YMxyCJADsNj!%u3tQHwzLg(R_+M*A
z&kSp2{m)Rz;D6W5;tscbn^sMY;-|Tr#M-PMPyVxCgY{~bkuP#j3DZ@wVA){m2L4no
zTgi43ZAIb(3Y4$q3LI8DCvh@5e`e$TC*CgJXC8Pn=M~h7IwG3&@X%z75~!A}n6ILi
zmzgcKK>8vIO@9q%TED)OY6&9+5qdfqoL9juGi^0$G_H0RYr%0T+Kb#Xy$<fUa?nsN
z2})f&yK)Ky_n-0P)i2AL-&a&Dk=AP{&TPimWgXbkAF%p6tiE$bUp#pBC}S6%&1PTR
Q{cZi1dl!J}Ref0f-~PxT^#A|>

diff --git a/technical-fundamentals/python/coding/problems/__pycache__/19_loop_detection.cpython-314.pyc b/technical-fundamentals/python/coding/problems/__pycache__/19_loop_detection.cpython-314.pyc
deleted file mode 100644
index efa61cbb048917bd570bf6fcb9687072b686fc8f..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 1307
zcmbVMOK;Rj5U%!XX7YeUA%uj801=5skT{Vd@epv?13^LotN;fzX&Fxs@vhSz+CABw
zoJIm64uClF7dY}y*jw-gt@gw%Xh6AA)%L(@kMyBjkM>uezp9z@M@EML&;IPU_`L=2
zF9n0+6%OmS(CNVz1nefPGtK76w{BYNwzk(D?X0`nor8vb1_FDH6>n*85-@hAAaEN_
z!@DpufCX5y%R808!+K>3k}+Kks`F5<eWp^K<-?(rsSb6V%B*hZmCbHj+z(Y=xgn%b
zag<kYx2YH=IophWVgr=mtiOQS9yCC+0JOC=q3ys8ENo~~!-Q!kaI_mRZ0qIDM%ok`
z5wS17037rYjP*|&p!=|8U3v!4#M~_0W!o%Zffd++<68*fen$NucXz|2BUFWaM~c7n
z-o$|D!$s=xaI>-4ct@Y;wNkYc>WuoG&82@Y6DspD6YpmJ9hLqrBAxlGD=UBavD8BC
z#^TQ<CBkOc*CN`MaTF#?t&VJlJ3{I($^3R#Z>Q3a(q=3l`)!pzO2iIAT;@rdws}+F
zdnDR&yPJ=2UP>%D&&P?{@_$pukX3dPO%D#ia;LwLc^e+k<HO<=6ZWwTQ7Jh2KpJ3N
z>z_iW2M@+1WzBhTS`L(j0OsKx+o)S=1Z!#(4G!7KMAG`1$q0C1VL^@IGp}+U%UC1V
z(UNNs8lHsGgZ;^wmqYu<PQ0$E2|~0CZ~-_;36D@D%7rLHobRN~PC`Cv@uU+bW#uU6
ztypC`iKUP!=W2@jPja5oK1Mv$TE&k#T4Y!|f;H34uv9e)$q<2zXg!BR3nlB5ZpB3^
z|I(saX3-oqi~zZ_jhnDH{$shy-D>2X61t<LVOD4AC=oF$RxljLSdp2g!YmpZFk`hZ
zWIh~UJTT7-*Gy~}8?t!O9D>5Zus;1g^vom`i96^whra1o&TY8ZI<tZ5EEY{)*S!4E
zshS2G^%~8i)j{Go4@HB|J>6~N8Y>3_MfVkTG{3AuW&-=4{(1FkG1Tko99D^Iwv6V$
tW{iEC0XF{$mi~sNf1KeLzdgOxV_!X+O~1JKX7$yTuYm612#R1heFxYd8#n*}

diff --git a/technical-fundamentals/python/coding/problems/__pycache__/21_three_stacks.cpython-314.pyc b/technical-fundamentals/python/coding/problems/__pycache__/21_three_stacks.cpython-314.pyc
deleted file mode 100644
index 388920f902ea9b2c7d4c3ac668483e48afd41c07..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 1935
zcmcIk&u<$=6rR~%w&S=-p=l}<Xw#rnZb`R4BE+FWNE}F|D!?X0NL4bLt|#@9_3n0N
zoXR&#Ai<Ff5*%~r!8iT{{s&IX4WS--D>5`a^4_eY*w8iziIx2M&9^ge-}~NsbLCWH
zioo-D;m_nJO2}`xIC_GSF^s_IlN}P#+hmPuy5?wS&DHLjr@ixJn=X>bS%uU1Xn&5t
z+MOqnx9x2E@4Qj+h^uaC>mc%%NHchX%cf^4o4rD8acL?aiA=~OHr0;{o#Yu$jdv$e
z+R)9oJX)eNS`6D@aENW2Xc`gi?9{Y-mgHoM+@ukmCuucu0B5yl8HfrP&oaJce9Huu
z2`p2wOw}@#sHUr1MAxDzh_`O)n{6q?hUW2}iZS6)(gXv-<c1djZqYsju;aY<6(KEP
z7s#iy4dHCiyCkIG$a#YM%`}&i_gE^j`?}qv#!WKabWE_D%MRD3!C0JfrCLd>8B=)V
zV&A0UXG%yF!j5ELg`dd$3lVD-UcYv2F9Zid?kD2miWI!n3$=*bSrYSfWw)EPct>QK
zrz$LZx}9fXoVSwfeptx-UMe~&ym6gr%#SIX;MJmMrWxZ|mTRsBW9Hmg`d7!_U=OJ?
z0MGm6kWjzzJHo++{Tl*L;-iw`0#yTDszdCsK8eT@8PN3s2xB}Y(p@<XyiIs{S<ZrO
zs*ELB0y3C0lQEPmet+m&XTMaZ<?CQgln1|K%X1lwSCuDnphz@wBQJEJP`<3g0aLSr
zu&moL{ytB;!UR(2uFTe(j%>gVSpfk16xuTYqiWgU<!NMJ1Hi57BEW=9Kg3T_t-+%G
z`_Z$al{sL{N6!mHlXLJ=o&{*Savtpkgf{^c9$h|?&nvpBZDz-%L&k=V^Z8H3P)w`X
zyI`EG7^voqPkQJ;NnNX68Pi+f1_=8_^!+at!{V#+0F#PsSg8&^AMi(a$K*Pp$ByM1
zILC5L^qE`ag_)VqDK9Vx`M=2|m(cy&04FyPHuekTC>!XYJ$UeF@4v_)m(ee(cib>S
z?ES4_fWhw{D`7ity*Y)`nZe}((>cXhCvSCAwBhb}(B<jq%?x9^iBvjGGLhws$#dxI
z0>UMPD*$E=?m4(?l9+L=Wpb~pg#u5f$8N${q$y)fT8<eG#Ruh-)zAw9{?rP<^RMA@
zIdovQY`Yu=FR`BC_}LM#=hvGR6X;$6cca7+kRF0<TD(VW=h}@n|MFaUN!==Qe_yV`
uJ`7Evuuok|>0y=7)t|}DU%mP_AAWhKPyYz&wDIkw?-#$j{EUEU{rm;_P=+)B

diff --git a/technical-fundamentals/python/coding/problems/__pycache__/22_stack_min.cpython-314.pyc b/technical-fundamentals/python/coding/problems/__pycache__/22_stack_min.cpython-314.pyc
deleted file mode 100644
index 9eecae1bcb1d6300d3f9f479fc785bd8f72c66ed..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 1616
zcmcIkzi$*r6rS1LTQBw<zl1RfmWVMjoQS>VN09<Wky6Bw$dN2yA%Q(w_QvtR-t00n
zXLPAfB2s7~B}EFlwEQ_KnJ%J0bie_o%zLwU_7M<NZ1LTjw>vZ6``-8N^xnoKf#=EW
zD`6=ik8v@2!eKCILC`1bB%$Av6>8{;XS@~P_{Yc^og;~N9(Lkmf@uP4e}*K%nzt5w
z`FWK`JnvVrsU@{}(hQ&CvgzB2E4`Ahrpiuy$0b)Hv(cr}h(e~hrB||QQ-$7eF}MLi
z3XIl>p$ReG`jqhxlLGk70Ebm_jwap=$s=Tv?>9A<30$V;GNH?aE;HdW6G>#ERbuue
zdw|`fjV_xsyZwWZ*|0WuH^xv$G(c(kBq8(UA#FVbuz}|JhQ<#Ttcb5_u5{c<jo8xh
zkE*!EGo#}(%geW8Aq`hsg5O<KJZ<-4!?R5(vNT`Z=*o85;nJkJj?13eEM%M&Z6SY-
zOI6&=c}K@*&oYh7SVzdEvS%a4gcOD`dtk(PX_Tr1nL*7leH7IP5D-_*sG<N8*p<Nv
zfD5!wR>`{e)vtuKAv;TcqMJ0Km+5uraN@@v=n_1|9@yGens>Pk6*pZaTTQA^kEUnC
zjY2`uw!v7Ir&_l~2GlfeI^I`%ac`ZmRLa7nh6Cy8G19x~eej_^3h<^+wh65@o+CV%
zdxk%M2X3Vf!uxDw35dyinxoL%Y6_s~sRqW=0FKYXLd7R2yL!_$c6i_t?^g#9+$DJM
zNHf&SX|@c(hcpA-=(zu53SRNlAw2ak0L0jup>k>l<0Am$VyVwCi$jDw2Kf3dMgF|@
zApPt5m>eUP@ZpE$Q0R@yt(6RZS(LWEt3pxYm7hWcbqo*w0swmQk+QK{Y7Swi5wLI%
zmI{p+AI05nzgr%R%UF4^a!2p<*m<OdbI+KB83b!iGS(^D-5g^u?VWC#58v!#Y(pq*
zav`}a7*ozKvp`7ABb)@V)8KnBxyV>*j1o7yhHISCvB}7Io-+p1<NA&TedC&;B0L2F
zovTj)y!j3OZeDm`|LqXK4Z{DT*Ek$bC%3iL3~gw7CH#9RG_1mD-?dzI2cBPTakCj+
zs4D(ip}UcgUI2LJQ%bk%gf9I<7XJ;V?tgplVxPVYr)cB;-9PU9{>y6up*!b4k0nDi

diff --git a/technical-fundamentals/python/coding/problems/__pycache__/23_stack_of_plates.cpython-314.pyc b/technical-fundamentals/python/coding/problems/__pycache__/23_stack_of_plates.cpython-314.pyc
deleted file mode 100644
index 304a78991bd04fe055d2253bdd50f36a090ed24c..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 1566
zcma)6OK%iM5U!q?9S@HM8?c=aD*=owt-v1hIB-BHj{{B=Eiix;3E8b?wigeKXNK-x
zqrI&}q;O0QNa2<o`8heJZ&6Mt7otrt$5i$1!Y&{}A8M;>s;aBL`f5)dsP6?le=Yo*
zedz=INte+Hhf2SRN)I+6VPC@<Gi=Q>-kNXx&tQWchr~P22A(FE1-$$7kOUjvMsWJ*
zC>6kY%udJDlG-9P!e?}8_;%_>x035Z*{RF2kSa@Ubfq#`S%}=S8!35>jyF{L>!=8<
zXafvOz<8U}#-D={*5MpW*gWJ>;-Q>2fwN#eXbGI9<}5X537sWOrp(kjm?(*`u06JX
z-H7zwmG;$K7^zcgZP*@A0n|qS7>bLmhYxOg7rqB*p>+YSu`PW5I=cli!&Kfg^0!ec
zDv@TU+hEqu3e)gx*e=z!Ft*NlnhUL4S!y`f<bI-O%lM|2O2_Dt?dbTbD(}kF==jX)
z>b)2fNVSv62g^!|RyQ^>-72zF<jd_&(GuITFe2A+)iqmX5vOG<EAGUVDsSg<TgPY5
zaZTOvvdt^k-%8cB`#BdyQ5x)*b9;26|CRA?GgzQLg5qTlc7fIEf0Ow2u>0ww9n#T^
z=t8g|Fj1d~)Pn>T;VElAMPzKCW!_f%(C)fkT2cp5w-M)Aks%g#?#(I&cB-IXbLoDM
z_NzmvO-v|2gPYJvRNgnC#7q3x!zl%d7QohaMBb4$RMK=*(QGh9MK?TE#~*b7#c({X
zP&G|fDu&R|pP-n4<jL{pgv>92LuOFs{~)6%lbS_=kIs=!Strm5s*c{WhbECBn+yGz
zV%`FTz;J-9qVhgKkhW}mUk4O+;HU+R#i|JR4}@hNUG+yOCSdvLyC>rDtuahSi-nHw
zV#^pN%weJ_V8|7}Dl0ql1{h^UFRNErI6#}Y)yS*@w*#5Am-Fqi)yYXm=HKs#eE8)c
z=j}{slV^o2O3szb^(iGhfx^z>j^dJJDHq15>~;tLA27+x*cPWU&pAi-IL1)5pAQHV
zQ5F)!9KDF*<qx<MyB^ZSab-80&|VOK+&EoSvk}_RbSvCuMdMUN^w$G%KCah6$Y7Z+
z4*I;LPN6f^qL)xS_ZefmbHG-9gXKSheUH9+_-&8<6Gp85<K>^fc>K)^K-J~>4}=Xz
Ap#T5?

diff --git a/technical-fundamentals/python/coding/problems/__pycache__/24_queue_via_stacks.cpython-314.pyc b/technical-fundamentals/python/coding/problems/__pycache__/24_queue_via_stacks.cpython-314.pyc
deleted file mode 100644
index c2168023d66dbd2da54cab67c6288ceb0650c711..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 1929
zcmcIk&2Jk;6rWkI*PFynQfQh&BlS~}tdeXfK5(ciBn|`#3|UGpC>c%GlV+Or?q+5j
z<eQ~dq8B83;LrmS94qn9aAa<XQx8Z5L(?PgjlFUTZF*@}^7EVD%)EK;_dc%9Hl_)D
ze=PkYf2M@|j*IdO#>%h_%7AQ>n0`#wsiEth@zyJ*a-M9_izN11a1%e{FA!K)7D?=H
zd0YNFZ;x=4t;$F@)wp_@G=oRDY*uXTX1@@dT-n-3A`?m`HvFtGGS7Hw>CI$xX(YYz
zVwi!#!J{o=XiSW^J!L9qNDlrjf)AVIJsNw9Bn{D%bly}Q;ya}3kia2<LuwAGIV5z*
zltaRJ+DvT{Gab)>zja&tw7=04J&}xqb<Us;frUflYCvLgnLMQJhajx4MY^l;z_Kl(
zFSSrQ>T)9wb@aK)Z;Qm}=-suo{YYj;s6#2fUQvQ~`jHXIUM3TsuI%=*4)2Q0@Ki@d
z-|XdCl;j<m-HHm8@1&xuqiZd8fNrrv$(c4h+1IN@--e9IOd7`Q{Mhf+62XKItIpqF
z!}<^u;$kY}@&UkP4X=Q>P6uR@Y<utDC8PuB64{`8G^StBuORVpCGvnA{}HCfRu6gF
z6E;x7^i<YvQiZHEJsa%i3PQIH#*&n4-H{1+rt#9Hfttm;b;fv><%SypKA)cWJV6_9
zPM-tubU=;>tv3Ed@nGXI{{7f;EA<BKCuO04PM(t?g$$?}5KT{^RkZ-ZxwE`Ha;GLT
z$EuwxJsAV;_$j>OUP9|7Z^)VBZ4H!@cmwX}@z#haRE?)jqt!DYK*#iq*;9+Cp9OK8
zF!dIq*kALwgWJ#2a`vZ-Kb$+pN$DjVJed<!M}v60<f0?~!^IfDm(^?FLY+s$7eGLM
zUK0JAaO(fj-`{(1@csTPiQX@S*thkv3~+^Sz94R_JXZr3Ksl)fFy}7LCQOQ*JWpR9
zDwc-EB6&8^S6)e&q0~%t3)7#>ixR<iC*iujX*XwZ!elU<pj)RI>*k$aiaPZ1L64{7
zojJyKrP3yqnaFa+)EwGcLU9SjGK#Ap>;lXKXnvV6Zj6#UJtH)jJ9TVgBqB{2gQ?<r
z0Soj4*Q_c;D=4Pmr>}u{`V9=@zdV==M*#>oAzr9G!TI6Z*%@g!0~?rr0aI3CDizMd
zNkfia!{ITy;-*)4eMG<w)q)LlO=D<}E0ofskkHj%$jWd2%)Jlqd@`Va2eY(s@78zx
L+uKhFsLsy6fl7Q*

diff --git a/technical-fundamentals/python/coding/problems/__pycache__/25_sort_stack.cpython-314.pyc b/technical-fundamentals/python/coding/problems/__pycache__/25_sort_stack.cpython-314.pyc
deleted file mode 100644
index fd8beb2454e4456d791b082b0f0c94cd21d5e435..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 1923
zcmcIkOK;mo5S}F|ik2ni(b{fW19`%LklJ(-7sw$f3gl1+DAblti~@nZps97mm?D|o
zl>_A@paI%rdoWPna?Q`lvAh*I<>ppxoMUHJQY-_Bb4hs^&d%=6e)G-aYQ0tg{0`>-
zjUQV8FK99T+>tV9qSA*=2-qE1Wty#8+FG@>eI7R0MF^}FHaw}F8NjtY2Z6I;Z8)EQ
zI(7xHVvo+0g3@JZxG!nhu#58DUM|){S(LvPsgQA0c;Dta&eAX`*xl&J0RZAN-yp?b
zh=?{ovjDWUS=II|WQcDLw6hL3SYXXT;t`VMv@RKoV=N_OagD__ma?&wjm0yTDP!@1
zik?~rT?wWUZ?%|O%cNe@VYCyC!Zlz>$I!e1vDJqFF2gg{e1@WMlt{J}9atzH`1h2M
z%I}0a-c|m0GJ7B*t^8}t%R7FYY9V)H@n}(su+{Umh}vl!g~{S}H*JL-k?Jr}e%{mV
zEcK(T6{kP?xy-f_(NX^OFStTzToJaVyjOUf$7!rNFV4Qfyfn7e5YC`vu>Rpy2dIFF
zXB?A*21?c73W{5-59_dL-FyPjLhC$y&)O_tYwSLzJ+OTXsc~LXVv5pkm~=(qN};<l
zZ8n%BMjBS(Zf6q1E^3@dNvKpSju4xoOPBhxPIs%EhiRJWPzyvoJBj+pei~1z&rrPX
z!y&Lz?JpAh7Z2$7)G;f07WboZp`Z?L$&aLxm(wU3mLxvp3<?8iVPOc!$-Amu)Q^DB
zngGZ%B+M)1dCVFyW>{NB<s{aSIX2lAKEryk<j3T776s~*oDp|&j`UAZOwuLKk(GMu
zBif<uW0d^%!+yATe}a!ON<4TnAF@gg>G+5TJJ0f>HbFy{)0_VX3-UZUzJLO=@}9Vf
zskg-4-ha5a^FiWvav^q(<saAd>N_H*iZl7YfXYevr+k}88#o`fvMhOju#{~@1#&FO
z`&T|lpkA!F=;XRLIV;9CQ)h1q-gHc}F-`L&#i4|qTH(BtwYmxE*uxLIVKUk|#rbwD
zl}_SRq#5V(6b2yYNn9eaK;kNjVg_dcHhvuOP-_`)b+u6F?##rrh(wZbjuXXn0+r`i
zrcI?sUPzd_y^hN3pK%EPZQ(>XbWxbu@J{U&O%Bt{#!0i`7Ow8)I9(+rQ_?IvYRBPg
zG&Y7;%;fTJ4GH*CuHXhiQxw{P%@{kZ16z6yi+?)Pzuf-mn?C!;t+U#%<=@#}<rSc6
G{QL)o)_E=f

diff --git a/technical-fundamentals/python/coding/problems/__pycache__/26_animal_shelter.cpython-314.pyc b/technical-fundamentals/python/coding/problems/__pycache__/26_animal_shelter.cpython-314.pyc
deleted file mode 100644
index 6e64350852e7dce58ce1e02686a649f6b5e4fcfe..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 2449
zcmcIm&u<$=6rNez>y495QkoyMq$Ev$fT8K8Edm4;Dz}1=+isyCL9^PfH_gIk*PR^~
z<>mttH^h}=j=u5FRDwMraq6vLihDugdvER3Ms*Mp9VyRm-@JMA-uJ$l$?LOrO<?@7
z@;LgdB*d@uF&yQA(z_0&BesMqKM+@?mRAjJtcu&xt)4qRbQVIF7R5>78q2~hy<rq~
zU1nPuw#tF6;+m&K-FiqabtA8S6zNd;ac*5}=_pP7ICvUVh(RRLy9ld~JZ=juU7?Mw
zIbB*3skkLBNmnk5*rL7Td0lo(x^hcs(=B74N^ZWNM7xM85rF<^P*l__dTS7uWd~8V
zjJLlLq6zDYxFL5C^QQb<I1(|8hvc76`y9yAd#$i5^I8%2V|<|ub30YLzRqpW3t~UZ
zno*!VFQbL)ojh?q$wHMm@QChb&UKZ383sCYE^Kao<wOYpxF3aIZ>Z33?m0RPc9JOY
z<Bjch()4%3MEh~(wD$B)nm9q)jFP)fOQm<>a5r-<zUd9}%67sSk<PdF@)-}tB-OqS
zJug36WO{zoIFH1#1&Ajd(HF9^_8W=)5BaADy9kER)5icXtM>vvI^xs$gsePVaY}S$
z1BjFv86z)eVZ5!TFw6CyJ*#G+=a%P1Nd#2#xr2lX11D33Pe=T;u=?GUIs#o$c8z+K
z)+Imz>uR32n>O1q=_v7D+m8n`bDp;ysZ7UF5+<qVsTXO-MRWidM1kjPt)e?^9cEa1
zWTZzy7{{L1mCD9~jQDYdvsETk7IQQ~;>owjuWtaRKMAWMNpgEOVF@80D-H;|P!N{L
zs>@7UBCO?>n6{uSh>W8GONA{aTTHf8*-~YT#g-|ySZ+;Ef$TMR8bqDR?E=}G1r?a{
zNP`E}26kILO1UGbZR#l0F1n|dp>Xv@uL}5<#)5%9MYk5=+pBPppRE~&VeD{~F~x`L
zG?c>*mut8s$3Wg?Wx<shlbb5kZIv_>-Ar{u&Cm=tr#MSRcc>rv@qgy`l=Ia7>?Mc+
zy=~&Pz5mW5`uXuRe-)XJvV0OmiYie{6qDSCgsz6ky>{3R^TqK*24>1Zy+VTMJO&ZL
z!w_vkISeA)L2~q#rTeIB6mZqC7COPrL_HKN^%~p=klrzfF;sr|Y=8T~iH#9VhSwxK
z`O172Z3;}zz+;3r`E)a6NO1k^<;TWh8JVI)o(D9_p}+*{zk~5Ixn3Y~&>np7IGhI)
zYi_1@C)JE8-tRfk;lI>;66O8BH3xX}CiEFoyx&31OqoV~TG77^iaD@C+6fYTTF#Mn
ziNsqZ-X+1ft&+9|F?vO>laU0y6dC=4z*qF|xT5X83Bjj*qDHs4&CTZ^4ZPwdYGDb9
z*Uj9-YlfFr(K#&+*)(bVF7VELDey~GJa3nax9L4~1%5=K>{W<IB`IZpLC7<|*bCo(
Y@xWg1)cU3&@!&%AYqQes2?$Q)Z~UCy6#xJL

diff --git a/technical-fundamentals/python/coding/problems/__pycache__/30_trees.cpython-314.pyc b/technical-fundamentals/python/coding/problems/__pycache__/30_trees.cpython-314.pyc
deleted file mode 100644
index 3da965ab80da1023cfd039df666ad540c0ed8957..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 1958
zcmb7E-%lGy5T5n@vQ03i4Unc#NN6E$fg^2H+N!E5@lYaFZhE5O0h!ZrUWaRsJ7;fA
z1W#65MLZ-`-ugH2_w*&&m!|4d-i!?8wKI1<1W_BcE8X0;yR$R1GxO~SmEkhr_;vC$
zSk(ajq)9%^46y!>2)eKZ4!a9$OtNXhg}a3{O=@ep)YlAYteMiBhK6<n9PJLvPD*PG
zaIQ~)V>I-JwQxN*4R8m&(U8Sd$3z|LUv)}OaTaQ&mvo@U)Q}fNvGimRM@dar*7|;%
z-}i*FzTy!Vfv<|+v}w}|RdLk|LvK6eimm%}JRbx1tUre<U1)%04#>h*NotPa6fhiZ
z0>Wy@r0(d_a2N()s^YrfydF1s-KRSa?g>T2Xpr@9rN-{VR^gMM0h+ir3E#3E<}jz=
zXpWAib;opcTSs%&%L1w^W6ujaT#yZ=hrA^ZCi3t%=W~CX>y7z_GDPrTM=G=J2_DHK
z%7xjA#jYn43gxEa_IC*viH$44USi)9@%P-9iG6!{`3F0QBo})Df3zsL*W9-y_jjVe
z_rk?iCu(}TXwnN4yS*=W;>h;nW)MBF+akv7?I!j|%dW)BCrj;pb;WfDCE%{B#_}MS
zE-q7FB_E>b!Woo}sbdl^Myfpn|2-2%=6V*PB2?#lB|>Ewy>&c<sE?<>H%JZ!B?^;S
z>VJ%&3mera-+_&pC@%wSEJvi7j*Ty)L5%?%n1v%&ujyhK_e6!n2#G3+nxXWBhpm6w
zODKpr8sbevs_42w6iB@E=!HvXOX-ELp;i}q6&Qc}N%{HJYfnng$F3t9pZsM=jFUG#
zb5EYL7$~HgR<GBozg#!MLZJP!>+Z(QPDmKj{jlSOgPjrAZ3QBcVG!{sc3nZNQe&>0
z5G8!qlTrlR9mx~i8znd7H;rFVjHxIgNUorG3}=Nj<tQ>m((&;-AA^*#{t_--pvnYN
zg&|RpEMXOCf`lQiBQ_jEnvO|5u5?P&CAQGJf~8^ocT;<>Ws7NRSUO8ks7jBJc?V<X
z?8r-i<Unrh1xX+ergFk>ZeHA8n5oARZzxl6*%6V_X_{uI#>5+FJR?w+rK{vDE%2p|
zrrHh|eg=jyd`#j+WwvMFA3M6b*s}-~p<FpGAxiV<pLZc1r%uIrsZTlRrhO^MY#Pat
zCf*|a9tnDu5;}U`d)js@$sV93L}@S<?swt145fiDvY)fzf2UbcJzkd+QA34kQhJ{R
zwbg&WomfEiS8miizY(I;u$>!D<EYmxF-a>^B;FyBYAq6?w?)j5c%{j2(i({g{1V!H
z45tOG$5{nMTD7dxNvB>b6W3ZDYzyR?pp+|9?zi#r6FN==JpqD}DJb3PJDu?;^>f*`
zDt?}^_6tET6_q0S6h%*CjGdamW`Bp3-(ckreduuYr?0#0#2jK%hmW2;e0p#K2u~)5
S+3?}Yv)fNU`wI}Jf&L8%IFM-o

diff --git a/technical-fundamentals/python/coding/problems/__pycache__/31_has_route_between_nodes.cpython-314.pyc b/technical-fundamentals/python/coding/problems/__pycache__/31_has_route_between_nodes.cpython-314.pyc
deleted file mode 100644
index 23df93827eaa1ccebc49fd1563d565b9aae49b6d..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 1307
zcmaJ=&1w`u5U!q?U3X)Q@h3(k8a2AIh?xXEBp?c2G$4x(njFM5v$MVK=%i=u?oEiN
zJ&1UaoIQFpHy^=A2%dC6Jb3b!u!IFqR`n#&2-?uqRn^s1^;K109y&AtxPFdp$KM#h
zcM^7&mouz)1DP%?Lcr$W4l`_=cxTSJ;~IAyM&KL-?kEJ_H79>zyr6(`aTJnaQwR=B
zK(+LPuBt3M7)qI%(8Q_KD0+8eZKC{HPTl-qy$Uj2cnpRGV4TIWaf3qOpkIuY3?~eu
zc<7y>_hMGQt-^MzmNrB!LL5Mw7GXe-talcfF3iKCGxHLlfx0oc&sr>CffKla=R4@9
z@PiO!h2=2mh|G<p$;wj1Pg?a<=@&;R*GHH3B3*jCPKb)lR4s)@Q^@n#ivLgxrG3=I
z%i6!E(x)Oa+Mk}9dgh};p_XH@az%--vFaNUwPYNH$(3eDHo_$#O_*rEy=q#i^rN&9
z%O`$YrS(KCY5(dpZ-ttxv||LX3$r4G<Pst4$@XeC$oWob1?Sm`y(}mH)KjzdxGhB=
zoWcUzvh;1VY0r(xo4KNgCJ^nkf_R|9pj__FAk&3~VM$uM<{eR{axR>eyJd#}CSVfF
zy<fA=YE?&}F{pz`s&3|Kku-m6G=;2GDryMNti*XNV}o#x{s|}7StuvbtP7t<PQ4lU
zJbUZYZ0-Hr+R(;>`PbgskUByk92+T*aEug1ax1ac=yrhfrL@sWh{yUp?}W+D&0)@)
zvC<}qrI0D-YJ?IR;at<~Mm#h|#dU0i#=Akhv(aqYsz@Rc0;&ngE9g5^?Vhc2Zb}CG
zMwJu@pY<*v^Pf?50{mXSOJlD}Xqpu;CuMBJ%oVbc6_qd@B{Q#{risn2%G4n=&1W>v
z@-WJZ2yJ~1Nf-LSSb2-cyV*@TKIF&8<5p=Ck9IyeKFGhB&6$$#+O8|Aavs!Cr-?s<
zMANI?zK;H5jMaHGvgs6%>B1MUWJA`lY1pb}2T@_G6b(sMG^=g=9?C-@FFC#bs~1`6
mdfwn0>LT9Kcxp;#(`Afp4*;9^3Zwm^%jhQ%?GGYq8}t`O(jhhg

diff --git a/technical-fundamentals/python/coding/problems/__pycache__/32_minimal_tree.cpython-314.pyc b/technical-fundamentals/python/coding/problems/__pycache__/32_minimal_tree.cpython-314.pyc
deleted file mode 100644
index aa4e0737632421ec155369a3608992bd3114a8d6..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 1415
zcmZ`&&2JM&6o0c{UK>LUjR_@@2m~cHlx#{k^iWlmdZ>|*+pYpRAZN6!$7Jbx*UXF)
zIj5CcRUBy5WB&#In@YXVy|h(N+#DH{Th;g0UKEh}4sU-m@9q1&ueo{dYz<KUU3n92
zn*jgNp%iBZ*z^g44EDfhccINRyF%EwYqU*mwk>V7ZEd$5?OcJbc@=!~4x9a{D^0+&
zwFJK1wYrs$FPEVK?jRe9c6|r!l_iK9y6U@Y(5k*7LyP5Sf+R_GprbTVEi13=jECYu
zAoI#sA`vnQbNA~Z8G|^t?nO%HY$v2&OPN!!={nwI&;`wW(8k`PHhtSSkk%yHm}$$m
zwCyt_cXD?}3eib>q7zab^ICwqfdSd{dJ*ga>=~c_0MNs`75J9zGoSf}Z~7L7wmg$U
zy)w`>w-17NB&18&ibY=^EtP3M+$gyo?sPZ0xh<o|`}zgd?(|bR2(%*lYkBP5S3)We
zZ=wU`eIwH+BGk(JWNYg?FG{qK2a!0uB}LF1ds>A1NfZY0t^O$K1p|@jAXeURtoPHz
z3)5bdJobh%eH4p<^0sgDL6k&;Am$ni-yDwfI_LAw3(oUqnd9c^>n7%<K0=kj3Apz1
zF{!^68WS7869*R7Clx|2G&YW_h^FWZp+$Nw)E(?zb$SCq2D^=<w7~9aQuZBow-WL!
z#D_I_!8$Edp2f2~M`{5TZil5r+<)&{5#2h9ynrBgImb#h)^z?<O|z?_o)6F~gGn7O
zE<dlmT)gzW`m%ZX=b9uVa=xW2Xj(?6L+iqMf<4BdHO>cVZxj>87Cs#X@!Yb&c|Vd$
z$5A4ZlymtZrPJhG(RPPC&{{^1Mp`JeHPBWt7D-EbpM_dPpz5f8gcGA^D5{ww`Mk5N
zRClqgs|Ygq|7G<ITvS_9*u1V%sYQ<mQU>Fr3cV;?%iNJdk7RPxe7m(}^U&HY(rqz$
z9wW?_b(S`@Qj%IF!!jyb6vnE@q<%e|(C4?CUlhlpilPAYD}<(B6hO}|1Dd;BLRivW
zMO@I$M_WI=!}2;>SINUhmBAmDTQGE5H5yWXg!SN%BoaXG=<yIAgtYJ=$zKwstdOEN
zI~xE+d~Y(j``K*VpUVxjQpRc%)x>0sy;%Xa_9txr4%>fQXP$le{k@F6cB*Xo+2Jow
Qe>!>%2v06y3yQ@40}~fG=>Px#

diff --git a/technical-fundamentals/python/coding/problems/__pycache__/33_list_of_depths.cpython-314.pyc b/technical-fundamentals/python/coding/problems/__pycache__/33_list_of_depths.cpython-314.pyc
deleted file mode 100644
index bdf8566e5e89e7b82e0f99cc01b383f42c7e994b..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 1985
zcmb7E&2Jk;6o0c{{z?<4V3O1=Elriw&}M_u0|%4~NTgC_U=^A}<gB*qakH@5b!W#Z
z$;lE3^-v;?{0sSSDsd@$0mP{{M^2S1@6CGMBvmRg(!PE3-kbONoB3q&QW<cuYp;X4
z4)8B+@?~WV8y+Cjhb?f}eOP0XT_;|<udV4)Uo)h!W=eC-lGb%-=^ufk-(%THS*QW-
zjTvyvmeDHQxstmExQEeb$)d8c(57&qP01;uzBB`2RhFIdJTxk==x~Fj6)%cn>B%6D
zl7^8M*7v&np(oP9S3Ke(@YCYgT~c~sYCH%MnX+}Cj^=BW1{*G*qz^5S%mJxwRiy5i
zj)q}%3L7$MIEFMGhQY10xGp$v#%<p8sn$`wKpjJeY<NpKdk9<FXFmh9QFax+W!ubQ
zj^^l&fvyc(Cs(gDG)>K2FYIwqB;E*lNAAz$X>Ts(u{PIRi>=fY!Q*XtNVQv?SnPN*
zq3}1;$o?+jBC$~t>?Za%BL1HHGO<5hUjD%jBFV*Wz@Od~+-vXIlKb0H;CtcSPA_VE
zJ3NwJnAqJtxgAHgAGd?(vE3E%qmb_;_R5MIV(;9z<F<KMZYN9Ky>!BLN4@8+o7VCy
zmrjc(Ftg+~l0KY3(X1a4`FpB5F!4XIU}|AdAg&12#iJ5(L$n3oAUayqAM9Ug_%Skl
z*r-Oi1~zU)dFNqcIU-B79GHhg)@<nF67Iz$ktrmI4<q4W=bSj9a0|G^Wn|K#>jqIE
zv8L%$HDw}I&wFUqhrtAVP=8*2`Tp$l(#zVFgR-bm2>nes6{evzn}-M(*Nw2t=(Oy*
zJ8`=g5|1r>((}TRX3BLtfk<Q+L_CUJSIkj5HP=lD-@fZfDS}5m$rIF7QKurRqy^n#
zMJmW7l;$sRqN#==$qdQH$8Wr_t+d|4{>;0vPuJ*e>{AobAsgO6rVkfm-_{WKrl1_N
zL1d_p_>X5$pGQ%sSLHUCn8rgH+_SQ26lpCtJp;X2GOZ&a=xOHM5s}}$0sUSquBxr-
zi$7`ungWc`_Mtj?5!wi0Vg^kbT2{j?;&nkm-v|=&oZ~8+=JcstGf1gCsTqAh7%4y<
zlrk)7g4|~QD43vf&QJa($%v4}c=A}}kSfh4PwF!dm4Sl)JFL_YaV+<1<A*7~9XO#@
zY6&iTBHC94Zst{z>Rq!FG{9?=_*En{DaJ}iL|)7-4b*?-OSR8NHNNg>O}wgsUfn*7
zN0P^DpjcsLbgw7FGf$YfgL)O(ROkORiYi94QK389>0vo|M+MC=wd7tGUqnHD6J#$a
zs3;I2_-6M{je^{sn^9W)JiGF%!bUA6o~$An=!~(~WnlAv!O9=7@{dt@_Qg*R`s~;$
dvHG*8zdiYN{}_-xp4Hi0zDM?C0z0I#{SU7KmtFt>

diff --git a/technical-fundamentals/python/coding/problems/__pycache__/34_check_balanced.cpython-314.pyc b/technical-fundamentals/python/coding/problems/__pycache__/34_check_balanced.cpython-314.pyc
deleted file mode 100644
index e2b2df71f9bcc434c8a8eed8e9a394e3f4a6575d..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 1393
zcmZ`&&2Jk;6o0c{UMFtiLfwQ0)Ih2P1IY%F0|&%~1F3`ztU`0BoY7`Iu9t3R-Pv&}
z=d=<C^-vK11E=2jQ{Yzi0*F&@j@&9&-Wz-Ahr}G-{@%Q|@Atmu{iRC_fX8|3S@Meo
z@DC}~@n(Qc`v?j+f{@*WeWuxU!q!b|-`4iNqn&+MyVs#>zYU?i$7X+NuLY<(D-gO}
zr|W%itqKdUXU~0Vp@;U`3ZzZ#hyDh%>rcqkX60feWu_yYWHN8tW$j=*6t^N();<?f
zs3b1^FNb7|(vls-&tn73gR|)--WJdW%|g)DQA69I8(K(c6Jg4<6FS-r8Pa;Cf1rfu
zWIfS|se*YGKs~^KY<j~4y9Gzq$KM0=@a|3cnhjXULMyaG2SYo7O`)D(AE9(lqjV%x
zjj)r7zCK&26284vaos-XZgopnC3gn;5moK=Gj$T_oao;vW$;ZdR36|>a+(KUsq9-3
z>pb{yclU0PNG;T9BJOW15%tD_7V$tPag=WNN3s{42&tnq4~Ans$Yc;_y+qy#hAKNw
z#YrA~w8!Iti0|^_D2-$+dOO2$+2DNMb-{Vrs<Pa9@%j>GmcNUlfD7>5wQ~}GEjK4F
zekUF*Z%%52d}wZ+*AY$87h;Fx{7`?efA#5m2nslC%E|(V>$2)R9PUc;G$(`&c*Htw
zTQyKul!RJB(RNBF7is^M>zwE|@u<rPN}uyYCK_wH{6bB$D^t(w=vBa^0aw=^E<C=n
z`mp}Eb?v7Gb%iMG=X8dqZFM@dFq}*5G6r4X{3Pp*Qo`86d!s0wTb4QRCo0!zB8AL2
zSF4mxi}Rc|JLZwrDmfl$k)v%HZHCb#t?Hzbpo()6Kfr}$8j51(NamN;mFhO@x{jcL
z|6kX@!c}$EBD$51#??P-{kNV~k8nG?rKf}*DOozlS(cg{+e|g_x7m))a(xYTMS|+f
z*HF-QFjhY&@!K0a6Z-zTXH=8A$r}C4p^=-c>9rL=!&X-jR&?u#4c&a6OE0gkx`B4X
z>>?=O563qgopzmO(;s00I2(l&P<nbi#FwBPR22CuA~o-H)^ZB=$}CF%li7ejRa<DK
zbn_h)6Pq#itO0D}PuTt)w*Ph(AAI)R7X^Fj)!EvE`#<0N@$4xeyjaEZO-}y;{;4qe

diff --git a/technical-fundamentals/python/coding/problems/__pycache__/35_validate_bst.cpython-314.pyc b/technical-fundamentals/python/coding/problems/__pycache__/35_validate_bst.cpython-314.pyc
deleted file mode 100644
index 06e261fb6bf63ee9cef7bc2b4d7eb74eb090f142..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 1389
zcmZ`&&2Jk;6o0c{UOQ>yws8|RpaxPUm^Rr|EfNRBg#)RC46H(PsGQMeJ#MyaX5HCw
zD(AEk2=!19|3+{8DR3)$0mP{{M{boX?~T1QRALTq-<$XL{eJIbZeG0506gxyualYu
z@HZLN@umu!^ie5bA3}Byc9>?@Nw@A<JGQoW9PRA5+Pw~4`#lKlyKMTG_F90pvjm~r
zb-LcIYgJl+yY?)m7JBHfEkWAUe(0}3yZ(|~ZC1`jQf4~RNhb5QUDkF-193l6W$kkz
zg-YVm|8hXiC@tA;{3bWREIFI3<81+5&@2RP?KiX?x}k-DHUXwgJE5c9kRhyB`nyVq
zPSz8hm@1f60n`Ib$R;;Tviq=aef&K@5AWWAuh}6BS!jiJ=wNCmuqo9`>?4%!ag+{)
zs*&!bqOVVuD#8yoDy#>)-HmSPs^sCJeoj?;{Y)K2Iw$z|%QW~V7b*|%COOW7uT=I(
z#5xadZ*PAaBvK1?oQNlzN<_U;phbKrlQ>E@`$O4_j)c@vng@fCKFnkgXT3x|3<fGY
zNX1be-1&$j!K4>y!4Go1H5irioX>hLI4@fj$F1|%bI2?I07U_3;JYiQB>r4zj$QnY
zJy=*D*GTiBxp7)YZGy27J0xd^x`W-TPd-GYfW4-yJg~PatG>hDwxmdNLRf?6tkbsD
zJlg64iHj)OPU++#?Z0)M6Wlr;bqSTy=RA>##+ojjt7&>=>bZhZ1&rt6>dLdmi^b(<
z^%t#cKQ+`MLD+BL3{2bVbZA{Tm)K)W+Ti>s>kU)Vv4xL^Q9AQ1aNbW;uG2&cnQ^X`
ziB602oc22Ak=80X7;2HDZvlM<(U4YkGD*<$%&F`j;LI`&MKKK|_kWg^>Nd-|ib?_h
zzpR0Ui|Q(>zH}rm{YmTJ<*a&yyV)&0CG=3q(mBYo)NpJw)x_VX8#?8B8Er-4DmhkA
z&~`9ZKPB<&(ycLle_1r9p>9}XoH;ad!<yb&0W@qynJTzd)D7Hhp7ZAySKUCb!F5q7
z;CIJ22%UDFCet4xeVmL!04O~@8sIBX4jPK$6+xOeI&C;5dutM<|H*W`pQ;V?64`tU
v#n@(yz4n2v{Q;Z5!RBAi+|$p#`=Vg4ygFNX`sC-wKc2h-RL_>Nc*E%*|L`vJ

diff --git a/technical-fundamentals/python/coding/problems/__pycache__/36_successor.cpython-314.pyc b/technical-fundamentals/python/coding/problems/__pycache__/36_successor.cpython-314.pyc
deleted file mode 100644
index 1c82ffeab03c058851f4c6c3b7e47becfdd68b78..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 1446
zcmZ`(Pj4GV6o2ELU9asne*ib7P1KfDNi9e=KvjW+5E2JcfefrdbEurvc0FzuHnZ-`
zIF)m<1VTL&)UVMmz~_KlnF}CJy*YBLTzPNTE&;V8`R#A!y?K9s<G1I|)&ZBl@;v>e
z0`NC&X3Hx9oAeNjU=Koe6SkRQmk3vGR<<4EY;(i6UE^MYj&lV<=Q=BI8LtVr=SvW}
z9p3TYxiE7JaNU{OR6`H-)g{Olj34@|(5gKpRg2k1EM;zDljc&l99!KP_QkDO+3IIP
z3Y8|-|FTcYIJ0ag`PVnV)H$21;pqrEU|0yIvez(9=!O*x=up6n86I-uh77}c*56S=
zwDYcLCse_-3h)u5LpHfqIJ*UVl@ERZ=;GNje9iV*$ihnKgdAP-&<lCM(OvZ^_7bdn
z7-s{as)Ttadgf?pmh|oQS-jgjo%N1&ReE>dSg#)|A<bjzfY-~_L2NXo@|I15Z?sT4
zz?1Y)2VbfDTag$Yyt}paU64v6)L|;_ZzvIWhk+5vzD$!i+vp8sH$Fg@ai)X*(Cp_j
zNb+tf?*@I9-^s**4&J{J=|PeRt#h^6AKEifG;O|!BHNrLx_SEe3?`-DLotFAsJko2
zB>tRV7`yl#doaH?t`hQLVSQX9RENcD#|=aiyakC%a=NHl*wEVK27(dnF36b%b}!4>
zC}4L>l4Y@WKatZp1B9>&k6F9L6=kK)l9(egkD}#Tu0_^+nNCv@YqZpBh^!w)sZ0$P
zy?CnV@~9~IJX(!lJO}44KCC}^<NU+glja3P=azqNs3t|@Wq68Q=0NvaPP^SEjzy8g
zVW9td6dmN<K}HzceQywFQ_Xx7^-`rxmP#S>C{k~t1KW%uO^+doVq;W#XJCXz-2#Q7
zxJCY|Mu<cMf0`oy2q%@I<tR!+QvZkH91jYHUq&#3S2H}QAhTUXzAcydQjQw4E+L1l
zr-T_OdDMJC@l)DPk!p*nMZ8@yx=i_X+$$1ProM=R2*p_Kn8c&c$MpI2>W9U)sGvw5
z?TSU*D3YiDs!_oNwS;gM?h4`}+;qaV7erTAQB?#b5{%$??icRctr|_IH^5?WI*M3k
zJu~d%lTjQuitH7|D;{>)baM8;X;}ZGa>O62b<|R(dK1OiVT?Vm16%zAHhzPRzj))p
dr{8}uV$Zw=TX}H*(Y>FJo&my>Wh}kO=^rQ=J4FBh

diff --git a/technical-fundamentals/python/coding/problems/__pycache__/37_build_order.cpython-314.pyc b/technical-fundamentals/python/coding/problems/__pycache__/37_build_order.cpython-314.pyc
deleted file mode 100644
index f50169a18fc0d7300a69010d47e2e98bd493b0d9..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 766
zcmZuv&ubGw6n?XlUDKMzY7d2=6k4c+TBj001?|a03sQ8Uo<f)H?z9=ZnGG|ON>1h=
z=)vCdFL)62CjKX025)-ltszLRzS)`@p%32MdEb2R=gwMnZWd4~w|<Lv9>7oMOa%Qx
zM$7o=!ybfW8@7lcTb}WjAoLa?q>GTv8yc2YpzfbKdfl_7XF?n6?@E!&gdpbBNg0)*
zj=rJk!%Nun9=-)g5xWU5NQ;D|i8trcoYaRqwFw4Tb&7ETU(Wq6jy6jZ`c#HXYy8XB
z@TPMxic^+OU5qVvRQ`%5M%zltJ6xt*CW31lC~mq+)~RxXTB?mwu5g{$;2>A+*l4$n
zWqZVSHCLJ;B91kC{x==Fx3O`=gfv_o3;udt@i^@<!;_X2Nt~@8bY&X1xioR6S*K@O
zxnxP63VFz|qy3DxHETSG_PZiWqg<t2-R<;jC5mDxa}ygLMQRQkm`Bx5(DY#pl*|mB
z`BA+wXq<>M>dv><K0p1s@MZhso5KI)&wjW+peK(8$@|Uker@O@X@m(NxmY4PZn)wX
z2YBd12rD@H&L?~p>Ix#tJpt_kR##O8KlbWWtLi!;MQ4uNhhYHzjH=>!r(Uvw>2+|<
sVzI?e3%YXrf^(j){J5Q`-HdOl1-x+W=xb=sC?RBA1F|#@u<;_`53mW8oB#j-

diff --git a/technical-fundamentals/python/coding/problems/__pycache__/38_first_common_ancestor.cpython-314.pyc b/technical-fundamentals/python/coding/problems/__pycache__/38_first_common_ancestor.cpython-314.pyc
deleted file mode 100644
index b77fb998fd283a5b97bf2fff880862d309291b8d..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 1463
zcmaJ=&2Jk;6o0c{UOR5$ez=JmP}&BP8b~&X9(q7rIFL%nz$!F{%2{pK<7Ufx)|nZn
za!!^&sE301H~Qyri}pe*PQBT3t6X_+*PDh4F^Av2kJ<P6n@<-n)d0`phi~Io2EgB>
zl*cIqHtV4<h6C`~eb{B1t&wcpH+D^J?poT~wY9wl9rG6W=3Q3&rJW|AZY_gvcdU-{
z*^M$Rz+H2Gr{X*4uPj5-(5~;UL#z6lTrHL@ghHe`)Nv|Q%gic!qXB;q%B=DY7hJ|s
z=6*LIXP9JcFM1anU>=;!HqbhT4ru0sHV*3A^ljh3geE0Sn6`XN+djjzPUh}O&f961
zw<GFc-UZMMFd&<Klm~kN2gbc$0J>=V0DfSH%xAvgo4$piEzhJ-uW^o$*~eir<g!At
zmGGWESuP8HxLM|UxYyb2WVVbSAL<v>wbM&wKh%oS-_C~KkBUp>p(Q?6-uE(n!XvG`
z&v$ly@?xR6JdXL(Ey=^~$kRMJ6mb+LTfL#^hJ7w{m?&>B(ub+=qO==}$KF7uj}qQj
z-WT_RUM!UkqO{*nMG%UJE1k;i!6>T-sOH1xL69}eVz)1vFJXb|4#F7Dz_nMW1TU8w
z6C1x12bMM_6_Q+NY)-2v&G0Tn7UBHRm~f2M*(WHBVZR|t5A5F*<pN-TN6^ju_^=Ky
zSi5D)I_i>&kc$W{E3*_&dheMPrQ5(GFQbsTK@f{rV^5ba^i-Jgey-xJF-+=kef4?m
z^xDev>S^=F?=^XiQkd`3<!M?*yG^_a0)fNEptT_Ar`=&fGLG<Q7$$SiQcw&#i3JyF
z5XcoOrx^r_2p$EY)-rxH)Lfx&34M9Syl7b^m4G@{1i!+Wkq;E1xJd4QvDQUH&e~!_
z|Ib?A@eR*H=2qka{+C%YP4!9hoUP@okgT1I4Nev=7&3O0Ig;z46nWt-CL0)|;BV2u
z71SjGHLZ3Kh%z>-P6<wHYZDW{FDq9jHhz&h?$t?!Bp003X%(fs$q4&7KSYkaKYE^H
zAX>=lC>AxC@+Qf*2yP=N`t_Uz&Hv=R{21@#71E0x!?Xr=k+|Ke(rSA{Y!X*1DOl#{
z(E#6*v`~>Y0acQ}_F`ic?!8rJ?w18WzLK;S>OpNIOiaeu+d8oIzhLW6*m`9xJp20R
ZZ^!J7Q)R2qp8j$4+sPY1@oc3W#y@G5L>vGB

diff --git a/technical-fundamentals/python/coding/problems/__pycache__/39_bst_sequences.cpython-314.pyc b/technical-fundamentals/python/coding/problems/__pycache__/39_bst_sequences.cpython-314.pyc
deleted file mode 100644
index f63b3bce2a8cfe58676b4230475613beb4301ba2..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 1404
zcmZ`&&2Jk;6o0c{UORD<(3+G4l$KNp2AT~@4<I2f9B`$|z{+h7k+a&Y$IX`YtTQuC
z<(w>mP!9!h<WHb~50|nRK%9DW<W@Ptdt+PukeI{UH}l@U-|u~Wbg5baJS*?LNdL6}
z{-MkKcvFQ<9-uOULkQVzXfVw-NVjfV4O`m{M>`EyyA4l!8_>3|LulV((?4~o26%T?
zA#~eLyY%teJT$;9d*<VZ9@<N*kS*(S=x;*3{ESR>RxHFq<T}=AE>ztqO08j^--~5Y
z`icuK)1>gf?vpXj3g=F$birE5O9X%!1e<K(>j>JQSqR!XysYie4K0MV2{vQe2_5Z*
z48gs^Z%NLZd51R>%43!bP&F_ho7^zL?!lq;=??%Me0vwZWydUJp%vPpgQ1<krclqY
zqENV}aW>%6C*8?-SD&rUX&-FQu?|}8?RMeH^!~AaLb-e0T=rtE2>$(|7u;1`ssLZo
zQx$w8^9MZ9D)?k~_q!k!n#<FaKfEb<+!+R%C&wa9;_PO3AUbi63ms=F=nwUAE`lWQ
zq~d<im-$h~dn(xbEILv;Qv77VMZ(oie^@L=(X8}5ii+Bt<j$+lSCE+c0L2I{z<1Zr
zN&L06Ja+Lr_F!piTq4bf<?Zt_Y7_K@#34C5R30o}dGaADBiLUSa|`TW6Z68u{;nWT
zb3)jJC#+ewWfkx85{V@gI3AATS@(@+MQ~eq<Xfl|eiWr5)tJ-DD>+S{Og@*<YXsv(
zczgYE<>{5HkIPSMYd=?HjUeooa0aGsHJdaqQ6#X)7_<^ay}UEXNXHVM4B~8NS&E`=
zDwWPs!9^ZL@*Sd6iy}qiokX$LGCdk-uF$rOHiKwLOIlDPh@4tP@grPVrl2UMj^y*&
zv{K$?TCbrpg8!e^z`{v&C50^<ndka!VO|=X$-<Ld52QG&(taHn(Q3C1#X6HK_}6qo
zr&NidB(XsT+IAWa#>(d;eq9*T=eMf48RCXBx|u@_H=JqJMnJ8WtEkS=uA^?yX5Fm5
zHn;KynhmaNe*eSq4MekEp~iFvm<KjSA_5ei9`<nyq=Oep{*o|di3Ba`wCEJ^jcyeF
z=hGH{A-B;=l+_N3vCSBJu?B4OPuTk%_WpJj9)0=!oe_KPmD&2EhrgWsboLxjy|{`c
HFvR`?%cC>V

diff --git a/technical-fundamentals/python/coding/problems/__pycache__/41_triple_steps.cpython-314.pyc b/technical-fundamentals/python/coding/problems/__pycache__/41_triple_steps.cpython-314.pyc
deleted file mode 100644
index a6f58d0b09cfeb16fb4a94bb9ca7aed22a50c5b2..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 500
zcmYjO!AiqG5S>kHZM7}pr677y5Q@~T)Po1{6N(1(B!-x5Z8X`0*=?n_9{dE4{(zrk
zuAaPAiuCGCs_4MHefuUaGnpJT8*4z(+WCrv0C?xiZ#X|>zDZ;XF0{ZEEr>TPxXvE5
zO9456lcP*oqMUaLrf>x}&dC!%NZK}Bh@o)BHC2}3I)7Xi@A}|wxzKq9l^vmOi@X$R
zOGjmpV&YrFjdt@`UK)i)k`j%LJje821=h%;ZudcwLE$)3j~!HgIFVKbLmdTv+!>5?
z=qE~BKQ=O(*kP(=kcN@IlNqMBu}X|QKJqL^S*$!`Rb~#eNnZCnU+dKRR(T%QXo6Kr
zvqdn41qf05WO(k)_;~3Rw>edz*bNg79=+I2g$QqwwkP_p1Xw1e__Tej63y5DjereO
uiiRtN@2y-#{#||YaS7`TtSr6N(<BW?u{y&hY24IsaaIySESfZ6@$5H3f@vlI

diff --git a/technical-fundamentals/python/coding/problems/__pycache__/42_robot_in_a_grid.cpython-314.pyc b/technical-fundamentals/python/coding/problems/__pycache__/42_robot_in_a_grid.cpython-314.pyc
deleted file mode 100644
index d9fd068ff11a463beed270bf0325fc65edfb48bf..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 769
zcmZ8fL2DC16n?Y2*`&5jixvZ+A{Z?VTDR5;9>kMk6sdKwo{}!xWZG=q%!JuVCAU3z
z@KVSR@aRFIf5t;V=OlRQtr{d(-`g69zU96B-kY5_-}`277UwSjTKUTF=obU{LCM6N
zzhHETAcbA<*;A-7&1#mmYPPnoLWAMs+$vAD08C?@!&R%{Hr%_`bbT7@yl<7jw@VN&
z>Vof7pqe|Sc2(Or&!a?}+^b$U<|elzA}N|k63EG1bQ^u-V@TmO>{|EV0kp8T3@=%m
z`K*pB=jK~=Yl7>O(V$K}GW(aJXCV>$ly(^BKt(O%Dz1A<R2}0y!Cd9CrR`9+jk70Z
zTxG`Hm#P!$g!o-E(%VV6N<6GYM~Szs<RNeB#JjV;{>F=h=ISWoZ`TwLTYXRSW?Mwf
zFkaj5iB{O*LWgnUb^E$4h1Zm=NE~=wCHG?9NxaRC0HM@DB!Vy?dbhiMGZzG*5K@Pl
z2Z35Z67%Ru1w#sBU~J|mg%8)y==Jg5$<m4bR326~v+@W(gG^omWHd%5FKLv54=4%S
z`iwypu#%0rqKXL3!hdwsC9GzrlT0ama|&t^(N=ZFxVqoPX%w|qbP<`9YK{>7jK)TB
z)GVdcMO~yoo6nCbJm|<)FXj)`Wvmg$WCO#Q%@`XOfvtRj8{hM@?;j18j-L(lrPTR~
X+2cWFkPKFjUkvlhsWWy_fUM^qfMKBn

diff --git a/technical-fundamentals/python/coding/problems/__pycache__/43_magic_index.cpython-314.pyc b/technical-fundamentals/python/coding/problems/__pycache__/43_magic_index.cpython-314.pyc
deleted file mode 100644
index 874e938c9e8edc170554dd7fa64ec8ddc8621ed9..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 973
zcmc&yO>fgc5S_IX6QC{SOKlMmQX(Nm&~6bufP}bkDH1AR3B)1Pa_voH>a3&jrjT0>
z{1keK)FZw15AYN4l~Zr6qAFKrHbkw|-Wh4f&$BzbZ{EzKx!G$#R;`{UzXZS^{+XKd
z4~$j_3}6#{@fy~J5$ld|9)RyGfbT9qI&WORM7V5m$@l8exN^kF4W}r*Npe$E-gZrr
z=`fAx5#YsErsdKaHOUR&BWya)z5~P*yASV0Tlj)^Cf1zNfyeizF(4An()9206Vj=}
z&^_Yp!VM7%50&Ym9=gbH7jB{r@*NFPc&!XOp~;zGt=N$ta)r61NV1#DcbI)qk;&zg
z)zuwISqgU(^>rCl826=7QClZbm@c<^Iu1KZn=s8~w{O~+mQfZbdRule+e%d@mupXh
zPPm;!L84>zZKc~UW`ZEpIy0eBL4b2a;5x0mMs5IO5aQ|yyB}-&?%wlbhCde%>jzaE
z9nmSU(lTJ<3aqpqfdTkHB8ZJ4Ijm5`R`?KS2^LE&B5|Hh5L3$%9T~hs`%GiRof^RJ
zQUz}i`aexXE(Lj98v<wOGij48!U|>`^Sh{;*?+aypQ!ffFgo~bRXeMNa;#mV8s4NG
zyv6P|x%0wRF9@eIeJ0)_9cMOpmmQ;xM!E1zze}TFXU~qE6&d;P<Q1D@8&i4F$>LtB
dULp@XbIZ9Q$F2}!JP)FF>d_dCE9C6;e*uWew#5Jd

diff --git a/technical-fundamentals/python/coding/problems/__pycache__/44_power_set.cpython-314.pyc b/technical-fundamentals/python/coding/problems/__pycache__/44_power_set.cpython-314.pyc
deleted file mode 100644
index cc38987d638ee87542290166e70d8bcfe74d4b46..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 621
zcmZuuy-OTX5TCbuE}j}cFrW!hApzkq<|$lZ5mH%12%-yGiOXj9>8<X)UFN-0uJVff
z3ECxHQV98nvTZ6m!y#H`=IM!r12b>F=Qs0~#$Sv8(ZbwKc1Q1DHU{K9DE)a-daw_n
z*nrQ%iUkP083_Fu$S18A*4{y5=!%mYqN;t#j7<a?%uE5XPuxcmJ=lePZ|xgEO1?L+
zEm|TJdlb2+y}?j;|9ap98uujQ(fxex(>m!9H2;cwR>D*PD%(Nb@R0FTex@xU4h{-z
z$JQ|3w^b&0j6x&Hlbsm3g~gFdtdXlLE60)w6rN=2bQx8gcBNHGOJ_-(FCTPt8n>0U
zac*SUwXH(Sq)0P;C`&B9=BjOEvl*4eslv!8`=RVsV^I`qUD(*FD8f-1&ukV+^xzhR
zsQ+Ve{_;Gzcy-O{cl&ew_w=ugA7?Jor%Z6SW`&7&aJS~8_aFq?Uu<5IK=!yD7m>fb
zsy|}E39{YjAy@UMHjHDWZ8rQWu-%fDa0hdFI8G54zHc-9v0bE{Tz$eR3h;cx?XG<x
O#LXm#+1r4CyMq7xHG13t

diff --git a/technical-fundamentals/python/coding/problems/__pycache__/45_recursive_multiply.cpython-314.pyc b/technical-fundamentals/python/coding/problems/__pycache__/45_recursive_multiply.cpython-314.pyc
deleted file mode 100644
index 066c77c16f8f62ab1b6b404064c1eeb63db8d737..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 541
zcmZWl%}T>S5S~qH{jbuC7X`IY2vWC#f`{TGhz9f|hL~(^G})BdO(nM+d<>6X1YgKp
zJ$X}#cy%_lC^#@P-~8_Ex6@c&0Fup(&uE(gyqaJt)(;pr2^8SM8n|o?;#Cc<)dI&3
zXabBHsgv5I;~tp;&f(HJyaxy=w+^Rlz+84gm5I34A8h|(Zqwe{n|Zlpe#x%NItrbk
zbXaLeQj@FqQ%roV%)8qq@-rn+amqv^#ZNH35rI~GuiL%lG$3#kiMtL8Kg_un!9YfV
zA9wnh4E;n%?Z=7_b3I5U57ID_*L;ZSRV)(4_YXW2L53<C2`|ZF9S!4rcbJz;p65%M
zYF`V_L&M)JsoEk_z!xw!|6$BS>)p7=iF<BU$uTuSFlE*R<{uSrhCstIF~E+Wz_GAK
z8Jr=b%s{)1^W@6r|EsV;h3W{?UBF9i4i^a>JFF_<G6hv;vSO~6q+u3|BV3_^xj>n3
OyxWYiuLd1m^?n1z%X4A?

diff --git a/technical-fundamentals/python/coding/problems/__pycache__/46_towers_of_hanoi.cpython-314.pyc b/technical-fundamentals/python/coding/problems/__pycache__/46_towers_of_hanoi.cpython-314.pyc
deleted file mode 100644
index 1c64b9912d23610ca8dfa0972c2348f5beb4c99d..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 671
zcmZuvy=xRv5TCbS-pM6KEFuy)@FTEjd=aBW5IZ4)1YM2QCCj?|&RgAkZ+Y)+!gX6%
z*w|TGY9UzqhuB!Sm0*=Fa>%vLY`j8oU}k=AzV<i6URhi?2`HD&|H?l&06*w47ksxe
z-9T5v9z^UuY%$BW9P9L9m+iV&&;6-EXT8W-hR9upV#)fEcM(GWkkX;kcn@-88~;gF
z79wRBBPBV3>Y`2uXli&0d(P%7fDB_R@Q96A#3*wtku#Wcf`K=W{tw;wiy3#2i+f1D
z4U<ivg{`y<-NwzO)iemHsRN-y)&xVP$B8vW@Is^bjuF~$jO6=<Kh)}lNUh=5*VkWi
zY!-Sy7YA!vB-w;pk&a}ZCdJyYl36kq(k6xB<;0GZ<f+PX`J9(pJuAf6@QqusrEi*8
z4dYQFRer6UG`%=Zq*OMsB98R}k~o8ER?*Zj1ID^P$-Fg3<la^9cRt<weDllY&9D92
zZDxv<(4Lq832oAzI6zQC1b7U#{Sl3(>$jV(>K?-8)IW^$X^gf6{I>U-*U^iJw!@$a
z?4-nnG>vX=sJn#dcWT@85+SNSp53`KR#{buyP5_PDRUOhk;@pHtpMwP@AO_je$%b}
KS%9mxoxcGTrHmN>

diff --git a/technical-fundamentals/python/coding/problems/__pycache__/47_permutations_with_dups.cpython-314.pyc b/technical-fundamentals/python/coding/problems/__pycache__/47_permutations_with_dups.cpython-314.pyc
deleted file mode 100644
index bff37c5fe0b0693fd2c90adac30933c73a47267b..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 899
zcmcIiO>fgc5S_JCH-&x#S`mWykf>BCv}KDxf&=1+KtdH*f>Tw?*jr+7Y-@I%Dz_Z?
z863+YQuqh_5q#y;TTvAC%FKqSNa4yz^E{pz&%S-*?bVe_K(=*jl6)5cKlx>5&Yxg>
zkAeXlf-hde3t_|^@SP_3ZWGdmar_#^3pRFrZxh;!r~F}CRJB)$HW7^lcD4m_mwf!3
zU;yvn(0TG1Ag0_+cq2N(7Y9_Cn(rLUD8NN_=f<oKAe~JZx~JS#30--pOo`dhsa$Ok
z`5<E99p%^!jb;vatDbzT6>3SDq^IR;%s;BgX!&4o?~_b2qp+8#<6Tr?+?Pg0oh*sM
zboZ#t;;^eS6Q)`gebdP^8Rc=3eUJs_?^D&)^3mg<P}nUEjm|S294Dp|#ATuH7yW8E
z2*NDOsiuMeSBT4Ha($a%0OugY(l3US^)r5qHb&96md%W*1FVP~u<=E#h#mz4@PR}S
z`$Ga;q>R1j7A{j*wdM%rrLmlFo$5?s%sUytk6Im9Df-{*LOu?c2-*Uz1a>c$u9d~Y
z8rA2t`4U-ePU6wSuZh*>f-&`5`-e8zpbB1LxJvN1JlE#rnQGIdKBj;h3@pojyH<Io
yU(mwse`V!E?wd~Lo~h*Zr`<d*Q}qm6lw&@cr<}P$h)Dy)^@&FdKCctl$-e=f!mVEb

diff --git a/technical-fundamentals/python/coding/problems/__pycache__/48_coin_change.cpython-314.pyc b/technical-fundamentals/python/coding/problems/__pycache__/48_coin_change.cpython-314.pyc
deleted file mode 100644
index 69e0693f2e71eaf9c709f04713e299e71aabe93d..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 610
zcmYjNzfToG5T3nz??eG1T3`%fB9Y_}Tudk^43z~Wgy<zu5iaZ9^4`ha?#t{x%<Hb;
z&#=_O#FBr;ZK>!mFND_FB~P4Wetk2u^X<HOJo^YpR$tsyy$ImaCljGO$asld3&)VL
zUD#oky@V`UfGl2sdfrA^XBpD&m2XX%>+Ds=7K{?FUJ}xnbexfC;Si3at#g2qutoU9
z`YdBdRJoHZI-0D7dvxvjqz<(99_KNw?p*l^mxx9Wm37@hSIW2qr5&P5BNtc7q9;J?
zk`s-Mu*P$H<xcs5k!Uy})tTWRQGbzzHT>Pi#wn*MiD#Akx{gwmBW`8US5+bE^^>70
zMI)6Jwc&%2?Q6vgT~?~c2dF>SvN3#fEB8F|qAyfWz8#F*Or8s+v=vt7InEG)C#2>z
znHFw=v4?-W`4(S$_x;1Kr$2T>c(EJ`V`_xr-*G7Mp9qKb7j7W~ItJVS32B5L!3SiF
zA6QwzX>xA*KT0@HNMO*VpoQO^DV(KfKaE{tM+5pzI9lk#IjV&6-9uCF8(j`-xsCn>
W&%^kR>zFZivjptfZ9;zt1AhTDmwveb

diff --git a/technical-fundamentals/python/coding/problems/__pycache__/__init__.cpython-314.pyc b/technical-fundamentals/python/coding/problems/__pycache__/__init__.cpython-314.pyc
deleted file mode 100644
index d2e5233c6ac9c8aef2a57c1993c57701ccee4603..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 200
zcmXwzK?=e!5JeM<B7z=5S0XxfFCIZea2;YZ+GvxMB&~Gkb-Yry-oUQhnSj2<%=^q@
z{$es7k${_iWZbVf{?MOvgCGxbATu(jyC<=|kh^$n5snV61I4|p9qg^SV&)yJ)AR;X
zd$hI0`_dv84S39QEi+y$&y^Njq4vCRP&Pg{8ZslKzCdZssX*m`F{!0zY*jYxaHEW<
T3f$U$_!@h;DDQ+)YLj4J>321p

diff --git a/technical-fundamentals/python/coding/problems/tests/lists/__pycache__/__init__.cpython-314.pyc b/technical-fundamentals/python/coding/problems/tests/lists/__pycache__/__init__.cpython-314.pyc
deleted file mode 100644
index b6932354d62e980bee3a87e61434cf2d8026b68d..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 212
zcmXwz!43g25QbYqM8XreIf*db#UqGFoSWJmcIdXNEwVRPkK&c~>J4n%wF&>>pKmgg
zKmWMj>$0H7;6rh~qW#5xP`3lz*@g|-h_9Z^Ho{)VV|9kDL+c=yo~{no)*LbM4(7Aj
z2}paiSHj!GqD)Khm}Hs~sV4i2PGyeTOXZ*_eP%QyCMA7<!kV4J+=Xu!f)qs;f;4#{
brbStG7P(0;3YWGO8pMt+!n?^ix6MFb^#(e0

diff --git a/technical-fundamentals/python/coding/problems/tests/lists/__pycache__/test_11_remove_dups.cpython-314-pytest-9.0.3.pyc b/technical-fundamentals/python/coding/problems/tests/lists/__pycache__/test_11_remove_dups.cpython-314-pytest-9.0.3.pyc
deleted file mode 100644
index 70129e5c7de7fec2bb040967d80fee9af8ee4e21..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 8120
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

diff --git a/technical-fundamentals/python/coding/problems/tests/lists/__pycache__/test_12_kth_to_last.cpython-314-pytest-9.0.3.pyc b/technical-fundamentals/python/coding/problems/tests/lists/__pycache__/test_12_kth_to_last.cpython-314-pytest-9.0.3.pyc
deleted file mode 100644
index e39906b6210349bf9dc260e0e7a4d6371230b326..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 6787
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

diff --git a/technical-fundamentals/python/coding/problems/tests/lists/__pycache__/test_13_delete_middle_node.cpython-314-pytest-9.0.3.pyc b/technical-fundamentals/python/coding/problems/tests/lists/__pycache__/test_13_delete_middle_node.cpython-314-pytest-9.0.3.pyc
deleted file mode 100644
index cfd5cc1b819bef933d79c73f7039ca501df97c41..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 10016
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
U^H2PKuI`JvR<3oG0ASDlA5=`9e*gdg

diff --git a/technical-fundamentals/python/coding/problems/tests/lists/__pycache__/test_14_partition.cpython-314-pytest-9.0.3.pyc b/technical-fundamentals/python/coding/problems/tests/lists/__pycache__/test_14_partition.cpython-314-pytest-9.0.3.pyc
deleted file mode 100644
index 041ba490f3528420585f9b1b5b038e74d2d5cb47..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 10295
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

diff --git a/technical-fundamentals/python/coding/problems/tests/lists/__pycache__/test_15_sum_lists.cpython-314-pytest-9.0.3.pyc b/technical-fundamentals/python/coding/problems/tests/lists/__pycache__/test_15_sum_lists.cpython-314-pytest-9.0.3.pyc
deleted file mode 100644
index 6ac9c13e322ad4904314fd33d600ad6eccb8f42d..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 7508
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
QT=&=U6WsVV0$?`$Ki90(m;e9(

diff --git a/technical-fundamentals/python/coding/problems/tests/lists/__pycache__/test_16_sum_lists_forward_order.cpython-314-pytest-9.0.3.pyc b/technical-fundamentals/python/coding/problems/tests/lists/__pycache__/test_16_sum_lists_forward_order.cpython-314-pytest-9.0.3.pyc
deleted file mode 100644
index da941ce55b753004d8db93ad13c46424c03a4399..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 14258
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
R<ZYifMdY>zh-j>S`VRmo9q|AF

diff --git a/technical-fundamentals/python/coding/problems/tests/lists/__pycache__/test_17_palindrome.cpython-314-pytest-9.0.3.pyc b/technical-fundamentals/python/coding/problems/tests/lists/__pycache__/test_17_palindrome.cpython-314-pytest-9.0.3.pyc
deleted file mode 100644
index 72a221a74d6f3fa4fae3671cb305cbc460f0209e..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 7034
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
P^lfOXpsXSwwATLuPkRZu

diff --git a/technical-fundamentals/python/coding/problems/tests/lists/__pycache__/test_18_intersection.cpython-314-pytest-9.0.3.pyc b/technical-fundamentals/python/coding/problems/tests/lists/__pycache__/test_18_intersection.cpython-314-pytest-9.0.3.pyc
deleted file mode 100644
index 56f74d86a912c1ee6f63efdef7639ce3e4164bbb..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 8103
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

diff --git a/technical-fundamentals/python/coding/problems/tests/lists/__pycache__/test_19_loop_detection.cpython-314-pytest-9.0.3.pyc b/technical-fundamentals/python/coding/problems/tests/lists/__pycache__/test_19_loop_detection.cpython-314-pytest-9.0.3.pyc
deleted file mode 100644
index 008bed592d64fe68b03582a2b66e8c63848d72c9..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 7661
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

diff --git a/technical-fundamentals/python/coding/problems/tests/recursion/__pycache__/__init__.cpython-314.pyc b/technical-fundamentals/python/coding/problems/tests/recursion/__pycache__/__init__.cpython-314.pyc
deleted file mode 100644
index 1e766e94c87d5269917d7aa537cd6885a5f0c119..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 216
zcmXwzL23d)5JkHcg9zpX?y?GDEZvJo2olJ8==79M=}h-f)ve4f+Z-iVa+@1u$Ufbm
ze^K>{Uwr<{<9w!)z7~I!_fH;o=^G3W2|m@EdQ#8&^;_{M-9t975#9w^pf!Qc0z39c
zv_W9KTAhGgKt2;*3Pw})5YX0+tZ9mUbd_n*1=9$0eW<+y>nm~x=-7WW*h>1A6vSvF
j3njlS$x$fFW!GP)o7Pvc!7Wcxi`-K({EoHOJWliv2Q)k*

diff --git a/technical-fundamentals/python/coding/problems/tests/recursion/__pycache__/test_41_triple_steps.cpython-314-pytest-9.0.3.pyc b/technical-fundamentals/python/coding/problems/tests/recursion/__pycache__/test_41_triple_steps.cpython-314-pytest-9.0.3.pyc
deleted file mode 100644
index 8fff9106b756897fdae9e7964a82c00ce3a089fd..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 7537
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
A`2YX_

diff --git a/technical-fundamentals/python/coding/problems/tests/recursion/__pycache__/test_42_robot_in_a_grid.cpython-314-pytest-9.0.3.pyc b/technical-fundamentals/python/coding/problems/tests/recursion/__pycache__/test_42_robot_in_a_grid.cpython-314-pytest-9.0.3.pyc
deleted file mode 100644
index 9f3617b576d8ae8f840e63e8b80fd779bc68b98a..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 5059
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
GXzah$FV<ZE

diff --git a/technical-fundamentals/python/coding/problems/tests/recursion/__pycache__/test_43_magic_index.cpython-314-pytest-9.0.3.pyc b/technical-fundamentals/python/coding/problems/tests/recursion/__pycache__/test_43_magic_index.cpython-314-pytest-9.0.3.pyc
deleted file mode 100644
index 88fe51d3a67bf8cbe741be7de427e455cd510006..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 5086
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%0AG3qLHH9P
zKO-G-@Q>v1pCbo8J^b^f-N<A+GWpBw=aJW%!N2)MA@)_2_`|L6v5s%N>3J}AY<KK*
nd+c<Jj6O(A?k48iiMbXz`Vb^9311P!hfz^j7WRPdt=Yc;1{~|-

diff --git a/technical-fundamentals/python/coding/problems/tests/recursion/__pycache__/test_44_power_set.cpython-314-pytest-9.0.3.pyc b/technical-fundamentals/python/coding/problems/tests/recursion/__pycache__/test_44_power_set.cpython-314-pytest-9.0.3.pyc
deleted file mode 100644
index 5be061828dda2c909b07bdb4e5aceacfe1e4ddf0..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 7076
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

diff --git a/technical-fundamentals/python/coding/problems/tests/recursion/__pycache__/test_45_recursive_multiply.cpython-314-pytest-9.0.3.pyc b/technical-fundamentals/python/coding/problems/tests/recursion/__pycache__/test_45_recursive_multiply.cpython-314-pytest-9.0.3.pyc
deleted file mode 100644
index 1ee731687b9ace373029ab05955e4e0b74c83adf..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 5587
zcmeHL&2JM&6rWwM?e$0OkklkCsMt^-rj8v4Lx~_1N|8eOsM&(KBpGe&O|tFUyUdOQ
zNma>}Dk0PZJ@&{kz4Z_1AJ9vsgai_;sM@Nh-e_~6AF9+h`(ZmIA@uH1cILe|Z{EC_
z`OU=dy&dZcBPc)g{-yrPBUEOLR|J>XSOlVhCXvKlLX@*xe#}?r51=uD`VTlg0UCrJ
z{*pKrqM-w5B9uZC;R5H_DDL%)w%SQP^G1uKQOVbbXxBtn3Q2-Dj>aZp#W!189!28`
z1bY5HBn1lKH!HMT;trv7@HfU>OLLY`l<92Q^?(VHA3h&^8%t0%&^XjiDY`a1p0!1$
z{X!|B@qi~Pp-jZ15%Rn+xLvG<T4Ow_#ChvA_!3vNPsHnU+G5vco^d7K8+8C^SUGns
z9kfDf)zAsm)G14-Q&qG2OhYN-X`)y0w5lms)5|hd^_msJMd`!$u3WtOk=0$*D|P6z
zwV1vY&~&+?5G$hGh0#uT+GmN(L`|+LmSC&-pvPo8dL)^&?&WTp3Ndq4us>(!ibVfd
zDN{3-9~$~3r`D)K=2Yd*AW`JXe2yyR*_v9GwZZ9ntpXNnRMyO#F;8dpTCS{D)Y?qW
zAo`T1R87z}!4Of(bz*|=HjfJ@uq&BUaJ8;c)zId%#=PZ+MamTt2fu>wnPX5j(9_6k
z56<2{yB5hWNAlkee0S-4@$s4BO5}Ru{iosH2ig1CwQzbloL+ouC7f$qSQo^5mp{L}
zChS`l_I-U}RY<N!VvP?rz!qBQ-)Zhm7s!L&#t|4Jg9{UIeI!Kr$sX$4i*&e90C_>;
zslSA1K=Q#M3RdC<ELL)sI;UK9*R=`93=OdB(Ty{JK)9JcgPRl#e%zZ7-Rf!L(Ki{r
zeW4_rf=#%6^C<Hk%FI6q?MLHH)E5Ou-d@A~3YYxHIVp0haGWo=8WJb*tvgT@+ebKb
z3Kd-82(&Y)7iQW9-Kn;l=waIPw6gDo@zL#OY~49;{8jK%^0lpS+i|U%CkeaiHt(C{
z-&NP=`5^^%)os3ZIe(`4x*%i(q@X000y%DzG&s(1ZI?F7-JYz~rcf#9dEvFQoD@3E
z8612(e7@5hxiRSn^aOWA&!G-_;D12}Jpin2(Gvpn@H?WXr-PmjdYm_DTl646Pk2Z4
zpbmOE=y?fxL_iPfpoi^{_aDCVyXRGZ_edf5xgA}|6NT1E%}kbc0^tNrLeNpELp!aL
zB)y|24c$~Bpiz=6gqeW=$MPBTLsrk$*n@Qpv#P+VldKw9h|4BKMKpPMz?jeH)21b`
z7UI*t`O(odw=lvwPNvQ9r!J8kwRMNm<^Yonr_GElD5TAF__O4w(>(%Qh$P_Tt?)UB
znjmJtGO_kx2&puPiwsiMtA<PzD+=9ss;)wOR5Mv%2O6f;kIh-Vu2pPRJfrDTvWD%*
zE`&{aT45Hf*m>J`h`25iq7$nZ!=^xZhn2gACfDpZGA%+ZsA$txgw5kDHs8)1Z)Z-l
zGpE{_cN|BZ3GzdmxM7pU84zRIg~ZsZ_uET$4-dPChuy=ohPMr(vM(Fc3s%j4AtY*`
zpAQ~d5(gh%hiWyRdYD>?9|dx8*shl2gKMJuw;~QM#g8`GCIO?G^dsAd!#)A4ZqF*4
zz>xykv;y?vaC2-s0b|!YezA@JzxyS%&T)Vp;d#5-a*hM-yY0}gc#e{*&Cb!a!p`yh
zR)Zk%&N0LAm1*HCvzP~dF~1zotcmX5ikPvH(ULe_wqLIBk!{40KM^wwU#w>pNWhm%
zHm!hoG4F`C)-XR|k>od!KMPtSwjTtHtuS^|KtM+^zFn6!_EZ2D$B<PbCghuHN=?U@
zWZ2zIU~E!&9m-gyl&Dj6xObqu2jj8^FGNKx)3O536oxEaSDO%qu@uHR`-YPqAnl3~
zCX0Iiya$)_IUn#3K0{F1zS<h;J(lP_afIayt=F;hC}y1(37)VlQSK0xDpsf|vVyLR
z>}O+Q&D>d*rOpUTd00UMvWSpQBP?0M_QcMjVJ0V#v@!`xG1<8$i^o;_MRq*TGCA8#
z=e-ioI9ar_<Xw=lWtvx@dgkLe?k9x4Kr1NmBkKPp+Wl4km)F*!2bZG<ALbuN4>v-8
p1OzVrdkh64OOeAX{v!>3J<+$8IJTTPwuE|~2ZG$-27=0-?LUaX#YF%B

diff --git a/technical-fundamentals/python/coding/problems/tests/recursion/__pycache__/test_46_towers_of_hanoi.cpython-314-pytest-9.0.3.pyc b/technical-fundamentals/python/coding/problems/tests/recursion/__pycache__/test_46_towers_of_hanoi.cpython-314-pytest-9.0.3.pyc
deleted file mode 100644
index 17f8cc9760c96cfb3a5557b7bf4cf9f1afa5e5df..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 4022
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
Sd$<~T;q`E5HVFW0vVQ?$5)oMd

diff --git a/technical-fundamentals/python/coding/problems/tests/recursion/__pycache__/test_47_permutations_with_dups.cpython-314-pytest-9.0.3.pyc b/technical-fundamentals/python/coding/problems/tests/recursion/__pycache__/test_47_permutations_with_dups.cpython-314-pytest-9.0.3.pyc
deleted file mode 100644
index 56cdf6f133a410e85b3d7cdc4b90d06ac19ba557..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 5159
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
BUzPv>

diff --git a/technical-fundamentals/python/coding/problems/tests/recursion/__pycache__/test_48_coin_change.cpython-314-pytest-9.0.3.pyc b/technical-fundamentals/python/coding/problems/tests/recursion/__pycache__/test_48_coin_change.cpython-314-pytest-9.0.3.pyc
deleted file mode 100644
index 7a1d6a35b683b340588e9ce53b1b06a43c75da89..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 5846
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
Y;-k{=ednIjDSVm93m5hg5PqqD0bOtY)c^nh

diff --git a/technical-fundamentals/python/coding/problems/tests/stacks/__pycache__/__init__.cpython-314.pyc b/technical-fundamentals/python/coding/problems/tests/stacks/__pycache__/__init__.cpython-314.pyc
deleted file mode 100644
index 100bccc9e116a92c10ef291927f739e61bad5b4d..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 213
zcmXwzF$w}P5JeM35kXI2XC<Pey?6u>!Fq|=QKP%bG82{UY(0us+SVJm*qea<;?EoY
zF#K`9*A+pJ!N<h;iuRZMLER2;7aK7YBe{ACYJ|OxVMVZIB!*mhb7feQJE8Ur^V#eS
z#(Jcy!P|sTr6qXOM{BgoCi{y`RgTuHjG-v~(OJ+gHTD1nxm|`ihieXx*eiWzND^a>
dPm*a-R-Hxe(o2R*YK021Bu98RrIgeR^aVBEI?n(A

diff --git a/technical-fundamentals/python/coding/problems/tests/stacks/__pycache__/test_21_three_stacks.cpython-314-pytest-9.0.3.pyc b/technical-fundamentals/python/coding/problems/tests/stacks/__pycache__/test_21_three_stacks.cpython-314-pytest-9.0.3.pyc
deleted file mode 100644
index 7ac9e88c506274100cc2518a81baf6340d8c3098..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 18237
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

diff --git a/technical-fundamentals/python/coding/problems/tests/stacks/__pycache__/test_22_stack_min.cpython-314-pytest-9.0.3.pyc b/technical-fundamentals/python/coding/problems/tests/stacks/__pycache__/test_22_stack_min.cpython-314-pytest-9.0.3.pyc
deleted file mode 100644
index 6dbe2ae7a8c4aeb7a79ffea7fcd1d4a7d27e2a29..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 19252
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
S%<*ad%ZR{@tP%k1QU3)lR%P!1

diff --git a/technical-fundamentals/python/coding/problems/tests/stacks/__pycache__/test_23_stack_of_plates.cpython-314-pytest-9.0.3.pyc b/technical-fundamentals/python/coding/problems/tests/stacks/__pycache__/test_23_stack_of_plates.cpython-314-pytest-9.0.3.pyc
deleted file mode 100644
index a20d856705a18a500fdd549d9649d2d9b7ff4347..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 14650
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
NgTq4K76QQw`wzWYTk8M-

diff --git a/technical-fundamentals/python/coding/problems/tests/stacks/__pycache__/test_24_queue_via_stacks.cpython-314-pytest-9.0.3.pyc b/technical-fundamentals/python/coding/problems/tests/stacks/__pycache__/test_24_queue_via_stacks.cpython-314-pytest-9.0.3.pyc
deleted file mode 100644
index eb1731c029bb66c067115a8c3e008cd122f6c4b7..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 14750
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
Zd!B@&llvz2jR!vu#MwQ|3=rDYe*q2M2G9Ti

diff --git a/technical-fundamentals/python/coding/problems/tests/stacks/__pycache__/test_25_sort_stack.cpython-314-pytest-9.0.3.pyc b/technical-fundamentals/python/coding/problems/tests/stacks/__pycache__/test_25_sort_stack.cpython-314-pytest-9.0.3.pyc
deleted file mode 100644
index 28f666667f66b2eff1c68077e11e36b535562e54..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 14076
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

diff --git a/technical-fundamentals/python/coding/problems/tests/stacks/__pycache__/test_26_animal_shelter.cpython-314-pytest-9.0.3.pyc b/technical-fundamentals/python/coding/problems/tests/stacks/__pycache__/test_26_animal_shelter.cpython-314-pytest-9.0.3.pyc
deleted file mode 100644
index 39d77c7a04ee47a71d71e85e57392599a6b861c4..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 8150
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
T+3Hu?eP5&p__2Ks2yN`&0yK?0

diff --git a/technical-fundamentals/python/coding/problems/tests/trees/__pycache__/__init__.cpython-314.pyc b/technical-fundamentals/python/coding/problems/tests/trees/__pycache__/__init__.cpython-314.pyc
deleted file mode 100644
index af304c85c7c3c9d0e12e735d4a0a90bde13f1976..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 212
zcmXwzK@I^y5JkHQ5eX--vl5}$izA3gtS4=zm}aJXRP~I^&el;}$<_^sz3zm+`1LBk
zQu*V4uPeN6gO3jL8SF3lgLm7*RcypijO6MrsNwf_2p?zIG7>|soURzwWRDm-hWTuE
z0&N^prSUQ$R7njE<J9O_Ws`kr5|yKIDq|>Wms$g{O|&^cL3Wp6&i<PHBS(k~QKXG_
cQ8X>;M`w}Sq|9(hE#Dw?<N&Xxl#-gBzVhNaXaE2J

diff --git a/technical-fundamentals/python/coding/problems/tests/trees/__pycache__/test_30_trees.cpython-314-pytest-9.0.3.pyc b/technical-fundamentals/python/coding/problems/tests/trees/__pycache__/test_30_trees.cpython-314-pytest-9.0.3.pyc
deleted file mode 100644
index 1bbc0fcdf7dc3662510b3530e383b7b5160ad5ec..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 3927
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

diff --git a/technical-fundamentals/python/coding/problems/tests/trees/__pycache__/test_31_has_route_between_nodes.cpython-314-pytest-9.0.3.pyc b/technical-fundamentals/python/coding/problems/tests/trees/__pycache__/test_31_has_route_between_nodes.cpython-314-pytest-9.0.3.pyc
deleted file mode 100644
index d93f8b6749f7fc730fb4e5ff042ba171d551f14e..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 9672
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
ZYTt~+?q9igr560u-^Pt?At3a!{{j5k&e;F}

diff --git a/technical-fundamentals/python/coding/problems/tests/trees/__pycache__/test_32_minimal_tree.cpython-314-pytest-9.0.3.pyc b/technical-fundamentals/python/coding/problems/tests/trees/__pycache__/test_32_minimal_tree.cpython-314-pytest-9.0.3.pyc
deleted file mode 100644
index b11d689bfccf870d46d0d0a7d167e96d4338d4b7..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 7622
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

diff --git a/technical-fundamentals/python/coding/problems/tests/trees/__pycache__/test_33_list_of_depths.cpython-314-pytest-9.0.3.pyc b/technical-fundamentals/python/coding/problems/tests/trees/__pycache__/test_33_list_of_depths.cpython-314-pytest-9.0.3.pyc
deleted file mode 100644
index 073432239bc69f39f5710f1b586bb378a3854e4b..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 8095
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

diff --git a/technical-fundamentals/python/coding/problems/tests/trees/__pycache__/test_34_check_balanced.cpython-314-pytest-9.0.3.pyc b/technical-fundamentals/python/coding/problems/tests/trees/__pycache__/test_34_check_balanced.cpython-314-pytest-9.0.3.pyc
deleted file mode 100644
index 198d7226cc209bf4830bfdec90fe77687eb7d370..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 5214
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

diff --git a/technical-fundamentals/python/coding/problems/tests/trees/__pycache__/test_35_validate_bst.cpython-314-pytest-9.0.3.pyc b/technical-fundamentals/python/coding/problems/tests/trees/__pycache__/test_35_validate_bst.cpython-314-pytest-9.0.3.pyc
deleted file mode 100644
index 0997dd5976d21b8e9580cbbf967883568b825d72..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 7633
zcmeHMO>7&-6`ox#$>ono$%<n;cB7U5s+Db#l;l4+cH_T7t{a)&$V`CBUaY8<#FirI
z*_9Ki3Bm#e93uf-pcetnK|pe_Zb6bmQ1nosD9}p*$x<w1prS319(qfy0BLjTo7vsj
z6-8V2!3_#{LB4(O&HwDoxAVO{kZOq|xc=P!pVI4Lgo@PgF3DBaeh*3=T|=610oek(
zivyu4u>%cAcDTbyiP%v{5iiICF+0|QuEsji)p)<))RBMQtt)W5CLVmjH|?Yr+J@|w
zt1X>Kle}_v>S`+gqMyst>@@fl&+_kf>sAEi!`qM+=@%Wp-KGh9kQ)6bH3wCJNO{Aa
zD7rmkd0^xy1pl=K5Op-noK)o9I=F-SXzqrqfQBQUtAGwBJRKpg7d2s%T4R10Pb&!C
zJk-R3kY`WIOLOk|mi0EZ3Zhr419TX<FsMdJtTb7xV!K=#A<~pxDwAzi%`EC;xH_qi
zmCB}Gt`-fuRIQMhp4Tp&`SJNzUL~!Q)zK+PW4UO45-C@WQ4^Dd`6iThlGPBAX%!V?
z(j*eg7J?Lu&ggzcA#Z1{SSGeIlTiN+E0f37pPEJ6%H*=ypJhrF+r&3Y<{O8wX^c*1
zY_m8~DHV<Kp|PpTDAZW7jk1-gP1_UIN~TyHEmg)dHC!Djo0AsgwxA*#o2H}deTVfM
zM!7U<*rq;W**&#s5{97}qc{z{iNfC+08vM)iRW&gx^-$Lky}jUKJNP6g+Iw(yp&%`
zT&|y6jkn+Kxz)20R~O^zoxMx(O#SSANxpgU7Z+Egor}`W*|W=%azBx(|7Z>BLNi-7
zwz_U3c}s2W6y!Fb@vE?nG-Qj{+U?Nus0tekmcFEkAj51ML^KKXC|$_5tVQft0oida
z3J+5z=^+?&!5!q8SBKWEWV-TT-ji#;g_R2{*=rhI69YP5R{>whTQ!<+ls-AQV9mN3
ztSVlnCTimK-a_aYOyu=*-*>X2^TPP|5ZZ-?CD(!Sd`Ea5ME7R0AoU4a%WHf3#C|ug
z7Sg0)*~`^zop+*sH~Bc+$2%KZN_u7ednX#^d)FJ8*VoaV4dqjQIZta={uM!!w6GR=
zqP{lHO4Gjjv&;Lq?Q#0(mxI1Vv}j=Vn~urH22I{HFJBQE>0sbl*1}p$ix<KfVVyTJ
z+~&<)pyn-}&%bw~Ld1I_-hD#Q5+{V3ctXHuwFE5l)XXky+Ech<DK?%mm9Z*T425lN
z1=jq$NTjkkW|J^3jZfG^BvhNul4Nk}Q&)~ixLUQT+DFBaZ&QW^SY#{vx@yzMREs)~
z4bBVSiYHIb3o}{j?o+M!&s{}1$#P~@tBZPas-?!?R!%zJBdRqYC-M-W&tMfmaXXBW
z#9s!ef(@!0n6&ADV`UwiHC(Jt)(mWtBqZx2Q>C(9s#p|FA%{h_>()edsyxcF>f`0=
zh*8!VoW^v^7&B=NBz2l~9U%HV##Kz(b(j>uRNZ{DRyHaOyyv3;z-D<2(>E(g(8inr
z_Xdr_L8IR>oVtz%jpG)@OF(dXVY;432OFCEWOVvuXeS)VrFcs+4dB$XNrC5}R_hZG
zb@XL=+pO@Be5dWh#AnAoKmF;6<@68Ul~&U`XU{FAI~QbiZitD+w7Md@zhzlnNOy9R
zEAPL>)w{A9u(%tlnmxxY$mCh~0#!owb3;5+P=OTO3f+E8@D&0;%U{m{AKz-vz!xSJ
zJp<nYUlHF4_$nUwjsZNm=vz@r6%N3dZrmSYcu66Kdw2)cDC%H%xgxxa3V8J)Oi%BF
zxPz+j+D3Rc6$e3VM3>#`z=Ac+;Kgm10Zi{B0j6mg+O@~TnC`hN3o?ksboYwv{+8u#
zhB3a!NusFY`tHiz0gJn#DvBz8CeOMTs1mB5yTUUC6-apm#(dd$zzYTNWV6E_Cs;n-
z1WJd!*Rr4b>?jC}2rh4Co*f10Z2XUof_pYYBV|wTQvsyCn*);GOZuN2lJs5*i`E}O
zxCfurwjHybA9dZyeR$xr*FQHt{mF9M>D4VS%;tW5;OlUxHU6&jwTxPKxo4sOBb;hw
zIHd`IAe@Z)w52(j9RCL+Kb*kjIjN+p&bfd}#u=4NY@m{ytmHYV^h(jQMH4FNx6~xa
z0;dsP+}r=0ra4s7FW;2jZ7lELhfh)SP0RW71f+A5HUiWxx@q2rpDtuA)`Z&8;0e0|
zHPhp7!}SnqCjhmhe}~@DU|e$MMQ>00^sb_qlQnx92p<rtA^&VaNm?%z{Zt&C339mO
z4u?C=4j8J-;QBoV2TB8j>s`m-j)E0)&M$jmD0m+g`>CMM7k5#iQqfJt0T5~wAA(zu
zK;?o)U(h&$Gd!=uuZ}qc&@pn^jYlA59pZ3;#U=*$mT8jgBhjWw2|6C@CWt!v+b#uo
z&--sZf>A96=ueRF1UOWHQ2|-<cvFyyJ)Ac|fsJPxy1H1<N&*Ri=J3O?A`p(^EUFgL
zgzIMu5(`IN@%ANzqb@fDP&g_;YwiUY(ozURI4bp8e;^zsYN00z@qBmTC<vTs;iu47
zZ-V%F$D7y344rK#4|qodXB@}#&BIeX$oRBESz2t<KJc?~CbB-jrNy;GA<_``iatTu
zE9$*HygP)wl0G)pLJ<BM(vpCW=^1|J@$pfyAog80l?nu#7)S;%(&1lwVBQ)3qCj~V
z({MA9AZ(SLNeALyIRHWC?sa$>z~&_y-2yap0$-psz~*5u2^2R8Vqq*M2H`S@i3P%9
zIf#}qmZ!=LD{&9)RhEh~v_pZY)bXIP9vgG(kh0IBZ*n&j<;J2qn?t2DNjjY*l6yR?
z3>2Y2Z~XxTfaSjZ3v%{@fw{}Sxd;lN=EbFS7if3RF|nA=uE_3hS<Wt`yST{}ikfbg
zyR-^!afLO(Ey(o2fMea0vvZdn6>6Wo$W`7DxbFbH^m`H1p<V{G^YF<lL1dkU6Lp=$
zb@!_c=t*6_K4p|?pb@OJ4j+QB1)qp2W~Hj@xDTcQAEAN<-SK%UE`cChb=|Td-dNNP
z+s37lDR>f4L7T1@%dpNyOGUeALf}(}k8LdhClsScz?WGp5!28x6YZc_bm{*4CQSPS
zF%<585D$e9Jcvg?w2I;GZ)7o?`wD?zV`8P$EkyPLsqCFicIZy%wZ~cO5Gd`z<{P+V
zn<U0vB<lL`UTBe|_-C;m`c({5fFjWvd?17`Wtbkh=-janWIFX@_#S29DEQe2B_isR
z&iR3DJvJnG?;xj}EMzLb<a{MNg-0NPj^ENid=(M|;jak&5-p*ve?i;-o^1Wq_V)%?
zlDij^yXSIWB=^;04<eF~{#Ob`5(|lrrLa;L@2A^tzjN!Idh&jv<@SkNC+hMyksU&A
J4S`^7{ug^vW>x?I

diff --git a/technical-fundamentals/python/coding/problems/tests/trees/__pycache__/test_36_successor.cpython-314-pytest-9.0.3.pyc b/technical-fundamentals/python/coding/problems/tests/trees/__pycache__/test_36_successor.cpython-314-pytest-9.0.3.pyc
deleted file mode 100644
index 6feb9373514dd297d10731582d4532ae28e57b28..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 9972
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
Cr6St^

diff --git a/technical-fundamentals/python/coding/problems/tests/trees/__pycache__/test_37_build_order.cpython-314-pytest-9.0.3.pyc b/technical-fundamentals/python/coding/problems/tests/trees/__pycache__/test_37_build_order.cpython-314-pytest-9.0.3.pyc
deleted file mode 100644
index c63508727dfa92f5a229ea18c5c6a500ff4cc070..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 5798
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

diff --git a/technical-fundamentals/python/coding/problems/tests/trees/__pycache__/test_38_first_common_ancestor.cpython-314-pytest-9.0.3.pyc b/technical-fundamentals/python/coding/problems/tests/trees/__pycache__/test_38_first_common_ancestor.cpython-314-pytest-9.0.3.pyc
deleted file mode 100644
index c947e70a826d4051dfb76648541f9d06a7490ce1..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 6196
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

diff --git a/technical-fundamentals/python/coding/problems/tests/trees/__pycache__/test_39_bst_sequences.cpython-314-pytest-9.0.3.pyc b/technical-fundamentals/python/coding/problems/tests/trees/__pycache__/test_39_bst_sequences.cpython-314-pytest-9.0.3.pyc
deleted file mode 100644
index df11c033087181ef6895645b273d2d18a2d09644..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 5623
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
a)M$GeYr8debF3kL8A@}xJp{!3>VE)4A_oru


From 7534edddfc862f9123c687f6fea26657deddf6c9 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Mat=C3=ADas=20Saguir?= <mativs@kamipay.io>
Date: Tue, 12 May 2026 21:53:46 -0300
Subject: [PATCH 14/14] linked lists

---
 .../python/coding/problems/10_linked_list.py  | 81 ++++++++++++++++---
 .../python/coding/problems/11_remove_dups.py  | 36 +++++++--
 .../python/coding/problems/12_kth_to_last.py  | 34 ++++++--
 .../coding/problems/13_delete_middle_node.py  | 32 ++++++--
 .../python/coding/problems/14_partition.py    | 40 +++++++--
 .../python/coding/problems/15_sum_lists.py    | 42 ++++++++--
 .../problems/16_sum_lists_forward_order.py    | 64 +++++++++++++--
 .../python/coding/problems/17_palindrome.py   | 24 ++++--
 .../python/coding/problems/18_intersection.py | 39 +++++++--
 .../coding/problems/19_loop_detection.py      | 27 +++++--
 10 files changed, 345 insertions(+), 74 deletions(-)

diff --git a/technical-fundamentals/python/coding/problems/10_linked_list.py b/technical-fundamentals/python/coding/problems/10_linked_list.py
index f9806f78..36e1ca7a 100644
--- a/technical-fundamentals/python/coding/problems/10_linked_list.py
+++ b/technical-fundamentals/python/coding/problems/10_linked_list.py
@@ -19,21 +19,82 @@ def __init__(self, head: Optional[Node[T]] = None):
         self.head: Optional[Node[T]] = head
         self.tail: Optional[Node[T]] = head
         self.length: int = 0
+        def counter(index: int, value: T, node: Node[T]):
+            self.length += 1
+        self.visit(counter)
 
-    def push(self, value: T) -> None:
-        pass
+    def visit(self, callback: Callable[[int, T, Node[T]], None]) -> None:    
+        pointer = self.head
+        visited = {}
+        index = 0
+        while pointer:
+            if pointer in visited:
+                return pointer
+            callback(index, pointer.value, pointer)
+            visited[pointer] = True
+            pointer = pointer.next
+            index += 1
 
-    def filter(self, predicate: Callable[[T], bool]) -> "LinkedList[T]":
-        pass
+    def push(self, value: T) -> None:
+        node = Node(value)
+        if self.tail:
+            self.tail.next = node
+        else:
+            self.head = node
+        self.tail = node
+        self.length += 1
 
-    def visit(self, callback: Callable[[T], None]) -> None:
-        pass
+    def get(self, index: int) -> Node[T] | None:
+        pointer = self.head
+        counter = 0
+        while pointer:
+            if counter == index:
+                return pointer
+            pointer = pointer.next
+            counter += 1
 
-    def remove(self, value: T) -> None:
-        pass
+    def remove_by_position(self, index: int) -> None:
+        pointer = self.head
+        counter = 0
+        while pointer:
+            if counter + 1 == index:
+                if pointer.next:
+                    pointer.next = pointer.next.next
+                    break
+            pointer = pointer.next
 
     def merge(self, other: "LinkedList[T]") -> None:
-        pass
+        if self.tail:
+            self.tail.next = other.head
+            self.tail = other.tail
+        else:
+            self.head = other.head
+            self.tail = other.head
+        self.length += other.length
+
+    def to_array(self) -> list[T]:
+        answer = []
+        def str_node(index: int, value: T, node: Node[T]):
+            answer.append(value)
+        self.visit(str_node)
+        return answer
+
+    def filter(self, predicate: Callable[[T], bool]) -> "LinkedList[T]":
+        new_list = LinkedList()
+        if self.head:
+            pointer = self.head
+            while pointer:
+                if not predicate(pointer.value):
+                    new_list.push(Node(pointer.value))
+                pointer = pointer.next 
+        return new_list
 
     def print(self) -> None:
-        pass
+        values = []
+        if self.head:
+            pointer = self.head
+            while pointer:
+                values.append(str(pointer.value))
+                pointer = pointer.next
+        print(",".join(values))
+
diff --git a/technical-fundamentals/python/coding/problems/11_remove_dups.py b/technical-fundamentals/python/coding/problems/11_remove_dups.py
index a7b12d7f..b2fae624 100644
--- a/technical-fundamentals/python/coding/problems/11_remove_dups.py
+++ b/technical-fundamentals/python/coding/problems/11_remove_dups.py
@@ -6,15 +6,37 @@
 
 from __future__ import annotations
 from typing import TypeVar, Generic, Optional
+from importlib import import_module
 
-T = TypeVar("T")
+linked_list = import_module("coding.problems.10_linked_list")
+LinkedList = linked_list.LinkedList
+Node = linked_list.Node
+T = linked_list.T
 
 
-class Node(Generic[T]):
-    def __init__(self, value: T, next: Optional["Node[T]"] = None):
-        self.value = value
-        self.next = next
+def remove_dups(head: Optional[Node[T]] = None) -> Optional[Node[T]]:
+    lista = LinkedList(head)
 
+    if lista.length == 1:
+        return head
 
-def remove_dups(head: Optional[Node[T]] = None) -> Optional[Node[T]]:
-    pass
+    new_list = LinkedList()
+    hashmap = {}
+    
+    def add_if_not_duplicate(index: int, value: T, node: Node[T]):
+        if value not in hashmap:
+            new_list.push(value)
+            hashmap[value] = True
+    
+    lista.visit(add_if_not_duplicate)
+    lista.print()
+    new_list.print()
+    return new_list.head
+    
+    # pointer = head
+    # while pointer and pointer.next:
+    #     if pointer.value == pointer.next.value:
+    #         pointer.next = pointer.next.next
+    #     else:
+    #         pointer = pointer.next
+    # return head
diff --git a/technical-fundamentals/python/coding/problems/12_kth_to_last.py b/technical-fundamentals/python/coding/problems/12_kth_to_last.py
index cfd10f3f..a0c5f028 100644
--- a/technical-fundamentals/python/coding/problems/12_kth_to_last.py
+++ b/technical-fundamentals/python/coding/problems/12_kth_to_last.py
@@ -3,15 +3,35 @@
 
 from __future__ import annotations
 from typing import TypeVar, Generic, Optional
+from importlib import import_module
 
-T = TypeVar("T")
+linked_list = import_module("coding.problems.10_linked_list")
+LinkedList = linked_list.LinkedList
+Node = linked_list.Node
+T = linked_list.T
 
 
-class Node(Generic[T]):
-    def __init__(self, value: T, next: Optional["Node[T]"] = None):
-        self.value = value
-        self.next = next
+def kth_to_last(head: Node[T], k: int) -> Optional[Node[T]]:
+    linked_list = LinkedList(head)
 
+    return linked_list.get(linked_list.length - k)
 
-def kth_to_last(head: Node[T], k: int) -> Optional[Node[T]]:
-    pass
+    # if k < 1:
+    #     return None
+
+    # length = 0
+    # pointer = head
+    # while pointer:
+    #     length += 1
+    #     pointer = pointer.next
+
+    # if k > length:
+    #     return None
+
+    # counter = 0
+    # pointer = head
+    # while pointer and counter < length - k:
+    #     counter += 1
+    #     pointer = pointer.next
+
+    # return pointer
diff --git a/technical-fundamentals/python/coding/problems/13_delete_middle_node.py b/technical-fundamentals/python/coding/problems/13_delete_middle_node.py
index 0447e1ca..ceeed5bb 100644
--- a/technical-fundamentals/python/coding/problems/13_delete_middle_node.py
+++ b/technical-fundamentals/python/coding/problems/13_delete_middle_node.py
@@ -9,15 +9,33 @@
 
 from __future__ import annotations
 from typing import TypeVar, Generic, Optional
+from importlib import import_module
 
-T = TypeVar("T")
+linked_list = import_module("coding.problems.10_linked_list")
+LinkedList = linked_list.LinkedList
+Node = linked_list.Node
+T = linked_list.T
 
 
-class Node(Generic[T]):
-    def __init__(self, value: T, next: Optional["Node[T]"] = None):
-        self.value = value
-        self.next = next
+def delete_middle_node(head: Node[T], position: int) -> Optional[Node[T]]:
+    linked_list = LinkedList(head)
+    if position == 0 or position == linked_list.length - 1:
+        return head
 
+    linked_list.remove_by_position(position)
+    return linked_list.head
+    # if position == 0:
+    #     return head
 
-def delete_middle_node(head: Node[T], position: int) -> Optional[Node[T]]:
-    pass
+    # index = 0
+    # previous = None
+    # pointer = head
+    # while pointer and index < position:
+    #     previous = pointer
+    #     pointer = pointer.next
+    #     index += 1
+
+    # if pointer and previous:
+    #     previous.next = pointer.next
+
+    # return head
diff --git a/technical-fundamentals/python/coding/problems/14_partition.py b/technical-fundamentals/python/coding/problems/14_partition.py
index 2a6aa993..3bccef7d 100644
--- a/technical-fundamentals/python/coding/problems/14_partition.py
+++ b/technical-fundamentals/python/coding/problems/14_partition.py
@@ -10,15 +10,39 @@
 
 from __future__ import annotations
 from typing import TypeVar, Generic, Optional
+from importlib import import_module
 
-T = TypeVar("T")
-
-
-class Node(Generic[T]):
-    def __init__(self, value: T, next: Optional["Node[T]"] = None):
-        self.value = value
-        self.next = next
+linked_list = import_module("coding.problems.10_linked_list")
+LinkedList = linked_list.LinkedList
+Node = linked_list.Node
+T = linked_list.T
 
 
 def partition(head: Optional[Node[T]], x: T) -> Optional[Node[T]]:
-    pass
+    linked_list = LinkedList(head)
+    left = LinkedList()
+    right = LinkedList()
+    def split(index:int, value: T, node: Node[T]):
+        if value < x:
+            left.push(value)
+        else:
+            right.push(value)
+    linked_list.visit(split)
+    left.merge(right)
+    return left.head
+    # left_dummy = Node(x)
+    # right_dummy = Node(x)
+    # left_pointer = left_dummy
+    # right_pointer = right_dummy
+    # pointer = head
+    # while pointer:
+    #     if pointer.value < x:
+    #         left_pointer.next = pointer
+    #         left_pointer = left_pointer.next
+    #     else:
+    #         right_pointer.next = pointer
+    #         right_pointer = right_pointer.next
+    #     pointer = pointer.next
+    # right_pointer.next = None
+    # left_pointer.next = right_dummy.next
+    # return left_dummy.next
\ No newline at end of file
diff --git a/technical-fundamentals/python/coding/problems/15_sum_lists.py b/technical-fundamentals/python/coding/problems/15_sum_lists.py
index bd170e5e..3859f35f 100644
--- a/technical-fundamentals/python/coding/problems/15_sum_lists.py
+++ b/technical-fundamentals/python/coding/problems/15_sum_lists.py
@@ -10,16 +10,46 @@
 
 from __future__ import annotations
 from typing import Optional
+from importlib import import_module
 
-
-class Node:
-    def __init__(self, value: int, next: Optional["Node"] = None):
-        self.value = value
-        self.next = next
+linked_list = import_module("coding.problems.10_linked_list")
+LinkedList = linked_list.LinkedList
+Node = linked_list.Node
+T = linked_list.T
 
 
 def sum_lists(
     list1: Optional[Node],
     list2: Optional[Node],
 ) -> Optional[Node]:
-    pass
+    
+    ll1 = "".join(str(x) for x in LinkedList(list1).to_array())
+    ll2 = "".join(str(x) for x in LinkedList(list2).to_array())
+    suma = int(ll1[::-1]) + int(ll2[::-1])
+    linked_list = LinkedList()
+    for c in str(suma)[::-1]:
+        linked_list.push(int(c))
+    return linked_list.head
+
+
+
+
+    # total = 0
+    # carry = 0
+    # dummy  = Node(0)
+    # pointer = dummy
+    # while list1 or list2:
+    #     value1 = list1.value if list1 else 0
+    #     value2 = list2.value if list2 else 0
+    #     total = value1 + value2 + carry
+    #     pointer.next = Node(total % 10)
+    #     pointer = pointer.next
+    #     carry = total // 10
+    #     list1 = list1.next if list1 else None
+    #     list2 = list2.next if list2 else None
+
+    # if carry:
+    #     pointer.next = Node(carry)
+
+    # return dummy.next
+
diff --git a/technical-fundamentals/python/coding/problems/16_sum_lists_forward_order.py b/technical-fundamentals/python/coding/problems/16_sum_lists_forward_order.py
index 0f988bf7..075c6ab5 100644
--- a/technical-fundamentals/python/coding/problems/16_sum_lists_forward_order.py
+++ b/technical-fundamentals/python/coding/problems/16_sum_lists_forward_order.py
@@ -7,16 +7,70 @@
 
 from __future__ import annotations
 from typing import Optional
+from importlib import import_module
 
+linked_list = import_module("coding.problems.10_linked_list")
+LinkedList = linked_list.LinkedList
+Node = linked_list.Node
+T = linked_list.T
 
-class Node:
-    def __init__(self, value: int, next: Optional["Node"] = None):
-        self.value = value
-        self.next = next
 
+def invert_order(node: Optional[Node]) -> Optional[Node]:
+    pointer = node
+    previous = None
+    while pointer:
+        old = pointer
+        pointer = pointer.next
+        old.next = previous
+        previous = old
+    return previous
 
 def sum_lists_forward_order(
     list1: Optional[Node],
     list2: Optional[Node],
 ) -> Optional[Node]:
-    pass
+
+    if not list1 and not list2:
+        return None
+
+    if not list1:
+        return list2
+    if not list2:
+        return list1
+    
+    ll1 = "".join(str(x) for x in LinkedList(list1).to_array())
+    ll2 = "".join(str(x) for x in LinkedList(list2).to_array())
+    suma = int(ll1) + int(ll2)
+    linked_list = LinkedList()
+    for c in str(suma):
+        linked_list.push(int(c))
+    return linked_list.head
+
+
+    # if not list1 and not list2:
+    #     return None
+
+    # if not list1 or not list2:
+    #     return list1 or list2
+        
+    # list1 = invert_order(list1)
+    # list2 = invert_order(list2)
+    # total = 0
+    # carry = 0
+    # dummy  = Node(0)
+    # pointer = dummy
+    # while list1 or list2:
+    #     value1 = list1.value if list1 else 0
+    #     value2 = list2.value if list2 else 0
+    #     total = value1 + value2 + carry
+    #     pointer.next = Node(total % 10)
+    #     pointer = pointer.next
+    #     carry = total // 10
+    #     list1 = list1.next if list1 else None
+    #     list2 = list2.next if list2 else None
+
+    # if carry:
+    #     pointer.next = Node(carry)
+
+
+    # return invert_order(dummy.next)
diff --git a/technical-fundamentals/python/coding/problems/17_palindrome.py b/technical-fundamentals/python/coding/problems/17_palindrome.py
index 6164ce1c..ecda0e9e 100644
--- a/technical-fundamentals/python/coding/problems/17_palindrome.py
+++ b/technical-fundamentals/python/coding/problems/17_palindrome.py
@@ -3,15 +3,23 @@
 
 from __future__ import annotations
 from typing import TypeVar, Generic, Optional
+from importlib import import_module
 
-T = TypeVar("T")
-
-
-class Node(Generic[T]):
-    def __init__(self, value: T, next: Optional["Node[T]"] = None):
-        self.value = value
-        self.next = next
+linked_list = import_module("coding.problems.10_linked_list")
+LinkedList = linked_list.LinkedList
+Node = linked_list.Node
+T = linked_list.T
 
 
 def is_palindrome(head: Optional[Node[T]]) -> bool:
-    pass
+    # pointer = head
+    # normal = []
+    # opposite = []
+    # while pointer:
+    #     normal.append(pointer.value)
+    #     opposite.insert(0, pointer.value)
+    #     pointer = pointer.next
+    # return normal == opposite
+
+    text = "".join(str(x) for x in LinkedList(head).to_array())
+    return text == text[::-1]
diff --git a/technical-fundamentals/python/coding/problems/18_intersection.py b/technical-fundamentals/python/coding/problems/18_intersection.py
index 78422b6d..9211890f 100644
--- a/technical-fundamentals/python/coding/problems/18_intersection.py
+++ b/technical-fundamentals/python/coding/problems/18_intersection.py
@@ -5,18 +5,41 @@
 
 from __future__ import annotations
 from typing import TypeVar, Generic, Optional
+from importlib import import_module
 
-T = TypeVar("T")
-
-
-class Node(Generic[T]):
-    def __init__(self, value: T, next: Optional["Node[T]"] = None):
-        self.value = value
-        self.next = next
+linked_list = import_module("coding.problems.10_linked_list")
+LinkedList = linked_list.LinkedList
+Node = linked_list.Node
+T = linked_list.T
 
 
 def intersection(
     list1: Optional[Node[T]],
     list2: Optional[Node[T]],
 ) -> Optional[Node[T]]:
-    pass
+    items = []
+    def pick(index: int, value: T, node: Node[T]):
+        items.append(node)
+    ll1 = LinkedList(list1)
+    ll1.visit(pick)
+
+    answer = None
+    def check(index: int, value: T, node: Node[T]):
+        nonlocal answer
+        if node in items and answer is None:
+            answer = node
+    
+    ll2 = LinkedList(list2)
+    ll2.visit(check)
+
+    return answer
+
+    # p1 = list1
+    # while p1:
+    #     p2 = list2
+    #     while p2:
+    #         if p1 == p2:
+    #             return p1
+    #         p2 = p2.next
+    #     p1 = p1.next
+    # return None
diff --git a/technical-fundamentals/python/coding/problems/19_loop_detection.py b/technical-fundamentals/python/coding/problems/19_loop_detection.py
index b3aaf99c..58d6becf 100644
--- a/technical-fundamentals/python/coding/problems/19_loop_detection.py
+++ b/technical-fundamentals/python/coding/problems/19_loop_detection.py
@@ -12,15 +12,26 @@
 
 from __future__ import annotations
 from typing import TypeVar, Generic, Optional
+from importlib import import_module
 
-T = TypeVar("T")
-
-
-class Node(Generic[T]):
-    def __init__(self, value: T, next: Optional["Node[T]"] = None):
-        self.value = value
-        self.next = next
+linked_list = import_module("coding.problems.10_linked_list")
+LinkedList = linked_list.LinkedList
+Node = linked_list.Node
+T = linked_list.T
 
 
 def detect_loop(head: Optional[Node[T]]) -> Optional[Node[T]]:
-    pass
+    
+    def visit(index: int, value: T, node: Node[T]):
+        pass
+    linked_list = LinkedList(head)
+    return linked_list.visit(visit)
+
+    # bag = []
+    # pointer = head
+    # while pointer:
+    #     if pointer in bag:
+    #         return pointer
+    #     bag.append(pointer)
+    #     pointer = pointer.next
+    # return None