Python Mastery Challenge: Roadmap Edition

Welcome to the Python Mastery Challenge! In this challenge, i will follow the roadmap provided by roadmap.sh to further enhance my Python skills and become a master in the language. The challenge is designed to help me reinforce my existing knowledge while exploring advanced topics and best practices in Python.The key to mastering Python is practice and hands-on experience. I will allocate dedicated time to work on each section of the roadmap, completing exercises, and building projects. I will append my learning in this readme file sorted by days.

Day 1 of Python Mastery Challenge (27 June 2023) - Datastructures and Algorithms 🗓️🐍

• 📚 Explored algorithms and their qualities

• 💡 Learned about data structures and their importance

• 🧵 Discussed linear and non-linear data structures

• 🔢 Explored array, stack, queue, and linked list

Day 2 of Python Mastery Challenge (28 June 2023) - Asymptotic Analysis 📚🔍

• 🔢 Explored Big-O, Omega, and Theta notations

• ⏰ Discussed the efficiency of algorithms based on input size

• 💡 Learned about the Master Theorem for solving recurrence relations

Day 3 of Python Mastery Challenge (29 June 2023) 📚💻

• 🔍 Explored Divide and Conquer Algorithm

• ✂️ Understood the divide, conquer, and combine steps

• ⏱️ Calculated time complexity using the master theorem

• 🔄 Compared Divide and Conquer with Dynamic approach

Day 4 of Python Mastery Challenge (30 June 2023) 📚💻

• 🔍 Explored the Stack data structure, which follows the Last In First Out (LIFO) principle

• ✂️ Learned about basic operations of a stack: Push, Pop, IsEmpty, IsFull, and Peek

• 📝 Implemented a stack in Python using arrays/lists

• ⏱️ Analyzed the time complexity of stack operations (O(1))

• 🧰 Discovered various applications of the stack data structure

Day 5 of Python Mastery Challenge (01 July 2023) 📚💻

• 🔍 Explored Queue Data Structure

• ➕ Implemented a Simple Queue in Python

• 🔄 Explored Circular Queue and its advantages

• 🔢 Implemented Circular Queue class in Python

• 📥 Enqueued and dequeued elements

Day 6 of Python Mastery Challenge (07 July 2023) 📚💻

• 🔍 Explored Priority Queue and its implementation

• ✅ Learned about assigning priority values and difference with normal queue

• ⚙️ Implemented Priority Queue using the heap data structure

• 🔄 Covered insertion, deletion, peeking, and extracting operations

• 🔢 Explored the applications of Priority Queue

Also learned about Deque (Double Ended Queue):

• 🔁 Understand the concept and types of Deque

• 🔐 Explored operations on a Deque (insertion, deletion, checking empty/full)

• 🖥️ Implemented Deque in Python using a list

Day 7 of Python Mastery Challenge (12 July 2023) 📚💻

• 🔥 Explored Linked Lists and their implementation in Python. Learned about singly, doubly, and circular types. 🔄

• 💡 Implemented various operations on Linked Lists: traversal, insertion, deletion, search, and sorting. 📝

• ⚙️ Also delved into Hash Tables - an efficient data structure for key-value storage using hash functions. 🔑🗄️

• 🌟 Building a strong foundation in Data Structures and Algorithms through this challenge! 💪

• 🔗 Linked Lists, 🗃️ Hash Tables, and 🚀 Python coding skills coming together! Exciting journey ahead! 🌈

Day 8 of Python Mastery Challenge (23 July 2023) 📚💻

• 🔍 Explored the "Heap Data Structure" 📊

  • Heap is a complete binary tree satisfying the heap property: max heap (parent > child) or min heap (parent < child).
  • Key applications include priority queues, Dijkstra's algorithm, and heap sort.

• 📈 Understood Heap Operations:

  • Heapify: Convert binary tree to a heap (max or min).
  • Insert: Add an element to the heap and maintain the heap property.
  • Delete: Remove an element from the heap and rearrange to maintain the heap property.
  • Peek: Get the maximum/minimum element without removing it.
  • Extract-Max/Min: Get and remove the maximum/minimum element from the heap.

• 📝 Studied Fibonacci Heap:

  • Collection of min heap-ordered trees with efficient operations.
  • Supports union, insert, extract min, decrease key, and delete node operations.

• 🔢 Python Example for Fibonacci Heap:

  • Implemented Fibonacci Heap and tested insertion, extract min operations.

Day 9 of Python Mastery Challenge (01 August 2023) 📚💻

• 🔍 Today, delved into the "Decrease Key and Delete Node Operations" 🔄 on a Fibonacci Heap 🌿

• 🌟 A Fibonacci heap is tree-based and efficient, surpassing binomial and binary heaps in time complexity for certain operations.

• ⚙️ Learned about "Decrease a Key" operation:

  • Decreases a key's value to a lower one.
  • Utilizes functions like Decrease Key, Cut, and Cascading-Cut to maintain the heap's properties.

• 🎯 Decrease Key Example:

  • Explored examples of decreasing keys from 46 to 15 and 35 to 5, demonstrating the Cut and Cascading-Cut operations.

• ⚙️ Explored "Deleting a Node" operation:

  • Utilizes decrease-key and extract-min operations to remove a given node from the heap.

• 📝 Shared Python Example for Fibonacci Heap:

  • Implemented Fibonacci Heap and tested operations with example elements.

• 🔢 Complexities:

  • Decrease Key: O(1)
  • Delete Node: O(log n)

• 🔗 Solved a Leetcode question "Contains Duplicate" using Python and a hashset. 🐍

Day 10 of Python Mastery Challenge (02 August 2023) 📚💻

• 🌳🔍 Explored Tree Data Structure! 🌳

• 🔎 Tree is a nonlinear hierarchical data structure consisting of nodes connected by edges. 🌿

• 📚 Tree Terminologies:

  • Nodes: Entities with key/value and pointers to child nodes.
  • Edges: Links between nodes.
  • Root: Topmost node.
  • Height of a Node: Number of edges to deepest leaf.
  • Depth of a Node: Number of edges from root to node.
  • Height of a Tree: Height of root or depth of deepest node.
  • Degree of a Node: Total branches of a node.
  • Forest: Collection of disjoint trees.

• 🌟 Tree Applications:

  • Binary Search Trees (BSTs) for quick element presence check.
  • Heap for heap sort.
  • Tries in modern routers for routing info.
  • Popular databases use B-Trees and T-Trees for data storage.
  • Compilers use syntax trees for program validation.

🌳 Day 11 of Python Mastery Challenge (03 August 2023) 📚💻

• 🔍 Explored "Tree Traversal" in Data Structures and Algorithms.

• 🌿 Traversing a tree means visiting every node in the hierarchical structure, unlocking a realm of possibilities for operations like summing values or finding the largest one.

• 🔄 Learned three traversal techniques: "Inorder," "Preorder," and "Postorder."

  • 1️⃣ Inorder: Left subtree ➡️ Root ➡️ Right subtree.
  • 2️⃣ Preorder: Root ➡️ Left subtree ➡️ Right subtree.
  • 3️⃣ Postorder: Left subtree ➡️ Right subtree ➡️ Root.

• 🌟 Embracing these techniques not only respects the hierarchy of the tree but also maintains the correct order of nodes throughout the process.

• 🌳 Dived into the captivating world of "Binary Trees."

• ✨ Encountered types like Full, Perfect, Complete, Degenerate, Skewed, and Balanced Binary Trees.

• 📝 Implemented Python examples for tree traversal and delved deeper into the exciting realm of Binary Trees.

• 🎯 Excited to tackle Leetcode's "Two Sum" question next! Let's keep up the momentum! 💪

Day 12 of Python Mastery Challenge (04 August 2023) 📚💻

• 🌳 Explored "Full Binary Trees" - every parent has 2 or no children.

• 🌿 Dived into "Perfect Binary Trees" - nodes have 2 child nodes, leaves at the same level.

• 🌳 "Complete Binary Trees" - all levels filled, last element may lack right sibling.

• 🌟 Python examples checked binary tree types.

• 📝 Practice with Python examples.

Day 13 of Python Mastery Challenge (06 August 2023) 📚💻

• 🌳 Explored "Balanced Binary Tree" with conditions for height balance. 📚🌟

• 📝 Noted complexities (time and space) of BST operations. 💻

• 🌟 Discussed "Binary Search Tree (BST)" for maintaining sorted lists of numbers, explained properties, search, insert, and delete operations. 🌿

• 🌳 Discovered "AVL Tree" - self-balancing binary search tree with balance factors (-1, 0, +1) for each node, named after Grorgy Adelson-Velsky and Landis. 🌟

• 🌟 Noted complexities of AVL tree operations - insertion, deletion, and search. 🚀

• 🌟 Delved into "BST Applications" - used in multilevel indexing, dynamic sorting, and managing virtual memory areas in Unix kernel. 💻🏆

• 🌿 Explained "Balance Factor" - difference between height of left and right subtrees, crucial for AVL tree's self-balancing property. 🌳

• 🚀 Explored "Operations on an AVL Tree" - rotating subtrees for left, right, left-right, and right-left cases. 🔄

Day 14 of Python Mastery Challenge (07 August 2023) 📚💻

• 🌳 Explored "B-tree" - a self-balancing search tree with multiple keys and children, ideal for faster disk accesses.

• 💻 Discussed properties, operations - search, insertion, and deletion on B-tree.

• 🚀 B-tree Applications: databases, file systems, multilevel indexing, and storing blocks of data.

• ➕ Insertion Operation - search appropriate node and split if required for inserting elements.

• 📝 Insertion Example with step-by-step illustrations.

• ➖ Deletion Operation - search node, delete key, and balance tree to avoid underflow.

• 🔄 Cases for Deletion - handling leaf and internal node deletions, and shrinking tree height.

Day 15 of Python Mastery Challenge (08 August 2023) 📚💻

• 🌳 Explored "B+ Tree" - an advanced self-balancing structure where all values reside in leaf nodes, enhancing data access. 📚🌟

• 💡 Understood multilevel indexing and its role. 🧠🔗

• 🔑 Key Properties of B+ Tree: uniform leaf levels, children count, and key limits. ⚙️

• 🔄 Compared B+ Tree with B-tree for data pointer location and connections. 🌿

• 🚀 B+ Tree's Efficiency: Faster operations and searching due to connected leaves. 📈⚡️

• ➡️ Unveiled "Searching on B+ Tree" - a step-by-step process to locate data. 🔍

• 🔍 Illustrated Searching Example with a clear visual walkthrough. 🖼️

• 🏁 Explored B+ Tree Applications: Multilevel indexing, efficient database operations. 🗂️🏢

• ➕ "Insertion on B+ Tree" - Seek leaf, insert, and balance/split. 📥🌱

• 📝 Detailed Insertion Example with easy-to-follow illustrations. 📝

• ➖ Tackling "Deletion from B+ Tree" - Search node, delete key, and maintain balance. 📤❌

• 🔄 Case-wise Deletion Strategies - managing leaf and internal node deletions, handling height changes. 🔀

Day 16 of Python Mastery Challenge (09 August 2023) 📚💻

• 🌳 Dived into "Red-Black Tree" - a self-balancing binary search tree with a color-coded twist, maintaining optimal data organization.

• ❤️ Explored Red/Black Property, Root & Leaf Properties, and Depth Property, ensuring a balanced structure.

• 🎨 Visualized a Red-Black Tree example, highlighting its color-coded nodes.

• 🔄 Unveiled tree-balancing operations - Rotations, including Left, Right, Left-Right, and Right-Left.

• 💾 Mastered "Insertion in Red-Black Tree" - adding new nodes as RED, followed by recoloring and rotation adjustments.

• ❌ Delved into "Deletion from Red-Black Tree" - a detailed algorithm to remove nodes while maintaining balance.

• 🔍 Explored Red-Black Tree's versatile applications, from finite maps to key Java packages and Linux Kernel.

Day 17 of Python Mastery Challenge (11 August 2023) 📚💻

• 🌳 Explored "Insertion in Red-Black Tree" - a process of maintaining balance and properties while adding nodes.

• 🔴 New nodes always start as RED to avoid depth property violation, ensuring a simpler fix.

• 🎨 Illustrated the step-by-step journey of inserting a new node, from traversal to color assignment.

• 🔄 Delved into the intricate dance of tree rotations and recoloring to retain balance.

• 💾 Perfected the "InsertFix-algorithm" - a powerful tool to ensure the red-black property post-insertion.

• 🔗 Grasped why new nodes are red - a smart strategy to ease depth property management.

• 🌲 Wrapped up with a complete algorithm to maintain red-black tree properties after node insertion.

Day 18 of Python Mastery Challenge (12 August 2023) 📚💻

• 🌳 Explored "Deletion from Red-Black Tree" - a delicate process to maintain balance and properties post-node removal.

• 🔴 Dismantled the intricacies of deletion, paving the way to restore red-black harmony.

• 🛠️ Illustrated a step-by-step algorithm for node deletion, covering diverse scenarios with precision.

• 🔄 Mastered the "DeleteFix-algorithm" - a dynamic tool to ensure red-black property restoration after deletion.

• ⚖️ Unveiled how a black node's removal triggers a dance of rotations and recoloring to mend depth violations.

• 🌲 Wrapped up with a comprehensive flowchart capturing the intricate workflow of deletion cases.

Day 19 of Python Mastery Challenge (15 August 2023) 📚💻

• Today i made the design of the WebApp (WebApp to download spotify songs, playlist and album)

• Here is the link of the design - https://www.figma.com/file/pse0oHpCz5vOCgnvj4QPxG/Downloadify?type=design&node-id=0%3A1&mode=design&t=KNRLIoR4cPq7U6Zd-1

Day 20 of Python Mastery Challenge (16 August 2023) 📚💻

• 🌐 Created "Downloadify" - A Django-React project, creating its first web page. Exciting journey ahead!

• 📚 Dived into "Data Structures & Algorithms in Python (Google)" at Udacity.

• 🔍 Explored the Binary Search algorithm: an elegant dance of target hunting in a sorted array.

• 🔄 Traced the efficient steps: target comparison, array division, and iterative repetition. Efficiency scales logarithmically!

• 🔄 Deepened the understanding of Recursion - a function's enchanting journey of self-discovery and reinvocation.

Day 21 of Python Mastery Challenge (17 August 2023) 📚💻

• 📚 Delved deeper into "Data Structures & Algorithms in Python (Google)" at Udacity.

• 🔢 Explored the realm of Sorting algorithms: Bubble Sort, Merge Sort, and Quick Sort.

• 🔍 Uncovered the nuances of Bubble Sort's naive approach: comparisons, swaps, and printouts. Not the most efficient, but has its charms!

• ⚡️ Unleashed the power of Quick Sort: pivoting, comparing, and fixing element positions. A versatile warrior with varying efficiency!

• 🌌 Embarked on the Divide and Conquer journey with Merge Sort: breaking, merging, and conquering arrays. A balanced dance of efficiency!

Day 22 of Python Mastery Challenge (21 August 2023) 📚💻

• 📚 Navigated through "Data Structures & Algorithms in Python (Google)" on Udacity.

• 🗺️ Explored the captivating world of Maps: akin to dictionaries, they house keys and values, revealing definitions to the world.

• 🔣 Delved into Sets: a sanctuary for unique elements, providing clarity and distinction amidst the chaos of repetition.

• 🗄️ Unveiled the enigma of Hashing: transforming values into hashes via the mystical Hash Function, encountering the phenomenon of Collisions along the way.

• 📦 Discovered the concept of Hash Maps: transforming key-value pairs into hashes, unleashing the power of efficient retrieval and storage.

Day 23 of Python Mastery Challenge (22 August 2023) 📚💻

• 🌳 Explored Trees: root, leaves, levels (ancestors, parents, descendants, leafs), siblings.

• 🌲 Tree Traversal: DFS (pre, in, post-order), BFS (level order).

• 🔍 Binary Search Trees: Search (O(n)), Delete (leaf: O(1), parent: O(n)).