4. Initialize Together AI clients.

• Sets up Together API key as an environment variable
• Initializes both synchronous and asynchronous Together clients

5. Define the models and aggregator system prompt.

• Specifies the LLMs to be used for generating responses
• Defines the aggregator model and its system prompt

6. Implement the LLM call function.

• Asynchronously calls the LLM with the user's prompt
• Returns the model name and its response

7. Define the main function to run all LLMs and aggregate results.

• Runs all reference models asynchronously
• Displays individual responses in expandable sections
• Aggregates responses using the aggregator model
• Streams the aggregated response.

8. Set up the user interface and trigger the main function.

• Provides an input field for the user's question
• Triggers the main function when the user clicks "Get Answer"

🐍 Tip of the day for experienced Python developers

📌 Use decorators with parameters — a powerful technique for logging, control, caching, and custom checks.

Example: a logger that can set the logging level with an argument:

import functools
import logging

def log(level=logging.INFO):
   def decorator(func):
       @functools.wraps(func)
       def wrapper(*args, **kwargs):
           logging.log(level, f"Call {func.__name__} with args={args}, kwargs={kwargs}")
           return func(*args, **kwargs)
       return wrapper
   return decorator

@log(logging. DEBUG)
def compute(x, y):
   return x + y

✅ Why you need it:

The decorator is flexibly adjustable;

Suitable for prod tracing and debugging in maiden;

Retains the signature and docstring thanks to @functools.wraps.

⚠️ Tip: avoid nesting >2 levels and always write tests for decorator behavior.

Python gives you tools that look like magic, but work stably if you know how to use them.

Topic: Python Classes and Objects — Basics of Object-Oriented Programming

Python supports object-oriented programming (OOP), allowing you to model real-world entities using classes and objects.

---

Defining a Class

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def greet(self):
        print(f"Hello, my name is {self.name} and I am {self.age} years old.")

---

Creating Objects

person1 = Person("Alice", 30)
person1.greet()  # Output: Hello, my name is Alice and I am 30 years old.

---

Key Concepts

• Class: Blueprint for creating objects.

• Object: Instance of a class.

• __init__ method: Constructor that initializes object attributes.

• self parameter: Refers to the current object instance.

---

Adding Methods

class Circle:
    def __init__(self, radius):
        self.radius = radius

    def area(self):
        return 3.1416 * self.radius ** 2

circle = Circle(5)
print(circle.area())  # Output: 78.54

---

Inheritance

• Allows a class to inherit attributes and methods from another class.

class Animal:
    def speak(self):
        print("Animal speaks")

class Dog(Animal):
    def speak(self):
        print("Woof!")

dog = Dog()
dog.speak()  # Output: Woof!

---

Summary

• Classes and objects are core to Python OOP.

• Use class keyword to define classes.

• Initialize attrinitith __init__ method.

• Objects are instances of classes.

• Inheritance enables code reuse and polymorphism.

---

#Python #OOP #Classes #Objects #ProgrammingConcepts

Topic: Python Exception Handling — Managing Errors Gracefully

---

Why Handle Exceptions?

• To prevent your program from crashing unexpectedly.

• To provide meaningful error messages or recovery actions.

---

Basic Try-Except Block

try:
    result = 10 / 0
except ZeroDivisionError:
    print("Cannot divide by zero!")

---

Catching Multiple Exceptions

try:
    x = int(input("Enter a number: "))
    result = 10 / x
except (ValueError, ZeroDivisionError) as e:
    print(f"Error occurred: {e}")

---

Using Else and Finally

• else block runs if no exceptions occur.

• finally block always runs, used for cleanup.

try:
    file = open("data.txt", "r")
    data = file.read()
except FileNotFoundError:
    print("File not found.")
else:
    print("File read successfully.")
finally:
    file.close()

---

Raising Exceptions

• You can raise exceptions manually using raise.

def check_age(age):
    if age < 0:
        raise ValueError("Age cannot be negative.")

check_age(-1)

---

Custom Exceptions

• Create your own exception classes by inheriting from Exception.

class MyError(Exception):
    pass

def do_something():
    raise MyError("Something went wrong!")

try:
    do_something()
except MyError as e:
    print(e)

---

Summary

• Use try-except to catch and handle errors.

• Use else and finally for additional control.

• Raise exceptions to signal errors.

• Define custom exceptions for specific needs.

---

#Python #ExceptionHandling #Errors #Debugging #ProgrammingTips

Topic: Python List vs Tuple — Differences and Use Cases

---

Key Differences

• Lists are mutable — you can change, add, or remove elements.

• Tuples are immutable — once created, they cannot be changed.

---

Creating Lists and Tuples

my_list = [1, 2, 3]
my_tuple = (1, 2, 3)

---

When to Use Each

• Use lists when you need a collection that can change over time.

• Use tuples when the collection should remain constant, providing safer and faster data handling.

---

Common Tuple Uses

• Returning multiple values from a function.

def get_coordinates():
    return (10, 20)

x, y = get_coordinates()

• Using as keys in dictionaries (since tuples are hashable, lists are not).

---

Converting Between Lists and Tuples

list_to_tuple = tuple(my_list)
tuple_to_list = list(my_tuple)

---

Performance Considerations

• Tuples are slightly faster than lists due to immutability.

---

Summary

• Lists: mutable, dynamic collections.

• Tuples: immutable, fixed collections.

• Choose based on whether data should change or stay constant.

---

#Python #Lists #Tuples #DataStructures #ProgrammingTips

https://t.me/DataScience4

Topic: Mastering Recursion — From Basics to Advanced Applications

---

What is Recursion?

• Recursion is a technique where a function calls itself to solve smaller instances of a problem until reaching a base case.

---

Basic Structure

• Every recursive function needs:

* A base case to stop recursion.

* A recursive case that breaks the problem into smaller parts.

---

Simple Example: Fibonacci Numbers

def fibonacci(n):
    if n <= 1:
        return n  # base case
    else:
        return fibonacci(n-1) + fibonacci(n-2)  # recursive case

---

Drawbacks of Naive Recursion

• Repeated calculations cause exponential time complexity.

• Can cause stack overflow on large inputs.

---

Improving Recursion: Memoization

• Store results of subproblems to avoid repeated work.

memo = {}
def fib_memo(n):
    if n in memo:
        return memo[n]
    if n <= 1:
        memo[n] = n
    else:
        memo[n] = fib_memo(n-1) + fib_memo(n-2)
    return memo[n]

---

Advanced Concepts

• Tail Recursion: Recursive call is the last operation. Python does not optimize tail calls but understanding it is important.

• Divide and Conquer Algorithms: Recursion breaks problems into subproblems (e.g., Merge Sort, Quick Sort).

---

Example: Merge Sort

def merge_sort(arr):
    if len(arr) <= 1:
        return arr

    mid = len(arr) // 2
    left = merge_sort(arr[:mid])
    right = merge_sort(arr[mid:])

    return merge(left, right)

def merge(left, right):
    result = []
    i = j = 0

    while i < len(left) and j < len(right):
        if left[i] < right[j]:
            result.append(left[i])
            i += 1
        else:
            result.append(right[j])
            j += 1

    result.extend(left[i:])
    result.extend(right[j:])
    return result

---

Exercise

• Implement a recursive function to solve the Tower of Hanoi problem for *n* disks and print the moves.

---

#Algorithms #Recursion #Memoization #DivideAndConquer #CodingExercise

https://t.me/DataScience4

Topic: Python File Handling — Reading, Writing, and Managing Files (Beginner to Advanced)

---

What is File Handling?

• File handling allows Python programs to read from and write to external files — such as .txt, .csv, .json, etc.

• Python uses built-in functions like open(), read(), and write() to interact with files.

---

Opening a File

file = open("example.txt", "r")  # "r" = read mode
content = file.read()
file.close()

---

Using with Statement (Best Practice)

• Automatically handles file closing:

with open("example.txt", "r") as file:
    content = file.read()

---

File Modes

• "r" — read (default)
• "w" — write (creates or overwrites)
• "a" — append (adds to the end)
• "x" — create (fails if file exists)
• "b" — binary mode
• "t" — text mode (default)

---

Writing to Files

with open("output.txt", "w") as file:
    file.write("Hello, world!")

• Note: "w" overwrites existing content.

---

Appending to Files

with open("output.txt", "a") as file:
    file.write("\nNew line added.")

---

Reading Line by Line

with open("example.txt", "r") as file:
    for line in file:
        print(line.strip())

---

Working with File Paths

• Use os.path or pathlib for platform-independent paths.

from pathlib import Path

file_path = Path("folder") / "file.txt"
with open(file_path, "r") as f:
    print(f.read())

---

Advanced Tip: Reading and Writing CSV Files

import csv

with open("data.csv", "w", newline="") as file:
    writer = csv.writer(file)
    writer.writerow(["name", "age"])
    writer.writerow(["Alice", 30])

with open("data.csv", "r") as file:
    reader = csv.reader(file)
    for row in reader:
        print(row)

---

Summary

• Use open() with correct mode to read/write files.

• Prefer with statement to manage files safely.

• Use libraries like csv, json, or pickle for structured data.

• Always handle exceptions like FileNotFoundError for robust file operations.

---

Exercise

• Write a Python program that reads a list of names from names.txt, sorts them alphabetically, and saves the result in sorted_names.txt.

---

#Python #FileHandling #ReadWrite #DataProcessing #ProgrammingTips

https://t.me/DataScience4

Topic: Django Models and ORM — From Basics to Advanced Queries

---

What is a Model in Django?

• A model in Django is a Python class that defines the structure of your database table. Each model maps to a table, and each attribute represents a column.

• Django uses its ORM (Object-Relational Mapping) to interact with the database using Python code instead of SQL.

---

Creating Your First Model

from django.db import models

class Book(models.Model):
    title = models.CharField(max_length=200)
    author = models.CharField(max_length=100)
    published_date = models.DateField()
    pages = models.IntegerField()

---

Making Migrations

• Create and apply migrations to sync models with the database:

python manage.py makemigrations
python manage.py migrate

---

Using the Model

# Creating a new record
book = Book(title="1984", author="George Orwell", published_date="1949-06-08", pages=328)
book.save()

# Fetching all books
books = Book.objects.all()

# Filtering
orwell_books = Book.objects.filter(author="George Orwell")

# Getting one object
book = Book.objects.get(id=1)

# Updating
book.title = "Animal Farm"
book.save()

# Deleting
book.delete()

---

Model Field Types

• CharField, TextField, IntegerField, FloatField, DateField, DateTimeField, BooleanField, EmailField, and more.

---

Meta Class for Model Options

class Book(models.Model):
    title = models.CharField(max_length=200)

    class Meta:
        ordering = ['title']  # default ordering by title

---

Relationships Between Models

• One-to-Many (ForeignKey)
• Many-to-Many (ManyToManyField)
• One-to-One (OneToOneField)

class Author(models.Model):
    name = models.CharField(max_length=100)

class Book(models.Model):
    title = models.CharField(max_length=200)
    author = models.ForeignKey(Author, on_delete=models.CASCADE)

---

Advanced ORM Queries

# Complex filters
books = Book.objects.filter(published_date__year__gte=2000, pages__lte=300)

# Exclude
books = Book.objects.exclude(author="J.K. Rowling")

# Ordering
books = Book.objects.order_by("-published_date")

# Count
total = Book.objects.count()

---

Summary

• Django models define your database structure.

• The ORM allows you to query and manipulate data using Python.

• Supports relationships, complex filtering, ordering, and aggregation.

---

Exercise

• Create two models: Author and Book. Link them using a foreign key. Then, write views that:

1. Add a new book.
2. List all books by a specific author.
3. Delete books published before the year 2000.

---

#Django #WebDevelopment #ORM #DatabaseModels #DjangoTips

https://t.me/DataScience4

Topic: Django ORM – Advanced Queries, Aggregations, and Query Optimization (Part 2)

---

1. Aggregation Functions

• Django provides built-in functions for aggregating data.

from django.db.models import Avg, Sum, Max, Min, Count

# Average number of pages
avg_pages = Book.objects.aggregate(Avg("pages"))

# Total number of pages
total_pages = Book.objects.aggregate(Sum("pages"))

# Count of books per author
book_counts = Book.objects.values("author").annotate(total=Count("id"))

---

2. Grouping and Annotating

• annotate() is used to compute values for each row (e.g., totals per group).

# Number of books per author
from django.db.models import Count

authors = Author.objects.annotate(book_count=Count("book"))
for author in authors:
    print(author.name, author.book_count)

---

3. Complex Lookups with Q Objects

• Use Q for OR, AND, and NOT conditions.

from django.db.models import Q

# Books with title containing 'war' OR author name 'Leo Tolstoy'
books = Book.objects.filter(Q(title__icontains="war") | Q(author__name="Leo Tolstoy"))

# Books not published in 2023
books = Book.objects.filter(~Q(published_date__year=2023))

---

4. Selecting Specific Fields

• Use values() or values\_list() to retrieve specific fields.

# Dictionary of titles and authors
data = Book.objects.values("title", "author__name")

# List of titles
titles = Book.objects.values_list("title", flat=True)

---

5. Related Model Queries

• Use select\_related and prefetch\_related to optimize related data access.

# Optimized: Single JOIN query for ForeignKey
books = Book.objects.select_related("author")

# For ManyToMany or reverse relations
authors = Author.objects.prefetch_related("book_set")

---

6. Raw SQL Queries (When Necessary)

books = Book.objects.raw("SELECT * FROM myapp_book WHERE pages > %s", [300])
for book in books:
    print(book.title)

---

7. Performance Tips

• Use only() or defer() to limit retrieved fields.

books = Book.objects.only("title")

• Avoid chaining queries in loops.

• Use bulk\_create, bulk\_update for inserting/updating many records.

---

Summary

• Use aggregate(), annotate(), and Q objects for powerful filtering.

• Fetch only what you need using values, only, and select\_related.

• Optimize queries by reducing database hits and using Django’s ORM efficiently.

---

Exercise

• Write a Django query that returns all authors with more than 5 books, sorted by the number of books (descending). Then print their name and book count.

---

#Django #ORM #AdvancedQueries #QueryOptimization #WebDevelopment

https://t.me/DataScience4

Topic: Django ORM – Transactions, Subqueries, and Custom Managers (Part 3)

---

1. Working with Transactions

• Django supports atomic transactions to ensure database integrity — either all operations succeed, or none do.

from django.db import transaction

@transaction.atomic
def create_author_and_book():
    author = Author.objects.create(name="New Author")
    Book.objects.create(title="New Book", author=author)

• Use atomic() as a decorator or context manager.

with transaction.atomic():
    # multiple operations that must succeed together
    ...

---

2. Subqueries and OuterRef

• Use Subquery and OuterRef to perform queries that depend on other queries.

from django.db.models import Subquery, OuterRef

# Get latest book for each author
latest_books = Book.objects.filter(author=OuterRef('pk')).order_by('-published_date')
authors = Author.objects.annotate(latest_book=Subquery(latest_books.values('title')[:1]))

---

3. Exists() and Conditional Logic

• Use Exists for optimized existence checks.

from django.db.models import Exists

recent_books = Book.objects.filter(published_date__year=2023)
authors = Author.objects.annotate(has_recent_books=Exists(recent_books.filter(author=OuterRef('pk'))))

---

4. Custom Model Managers

• Add custom query logic to models via custom managers.

from django.db import models

class PublishedBookManager(models.Manager):
    def get_queryset(self):
        return super().get_queryset().filter(is_published=True)

class Book(models.Model):
    title = models.CharField(max_length=200)
    is_published = models.BooleanField(default=False)

    objects = models.Manager()  # Default manager
    published = PublishedBookManager()  # Custom manager

# Usage
Book.published.all()

---

5. QuerySet Methods: Update, Delete, Bulk Operations

• update() modifies multiple records efficiently.

Book.objects.filter(author__name="Alice").update(pages=300)

• delete() removes objects in bulk.

Book.objects.filter(published_date__year__lt=2000).delete()

• bulk\_create() inserts many records at once.

Book.objects.bulk_create([
    Book(title="Book A", author=author),
    Book(title="Book B", author=author),
])

---

6. Using Database Functions

• Django provides built-in SQL functions like Lower, Upper, Length, Concat, etc.

from django.db.models.functions import Upper

books = Book.objects.annotate(upper_title=Upper('title'))

---

Summary

• Use transactions to maintain data integrity.

• Leverage subqueries, OuterRef, and Exists for complex logic.

• Create custom managers to encapsulate reusable query logic.

• Apply bulk operations and DB functions for performance and flexibility.

---

Exercise

• Create a custom manager for the Book model to return only books published in the last 5 years. Then use this manager in a view to list all recent books along with their authors.

---

#Django #ORM #Transactions #Subqueries #CustomManagers #AdvancedDjango

https://t.me/DataScience4

Topic: Linked Lists in Python – Part 1: Introduction and Singly Linked List Basics

---

What is a Linked List?

• A linked list is a linear data structure where each element (called a node) contains:

• The data value.
• A pointer (or reference) to the next node.

• Unlike arrays, linked lists don’t require contiguous memory and can grow dynamically.

---

Why Use Linked Lists?

• Efficient insertions/deletions at the beginning or middle.
• No need for pre-defining size, unlike arrays.
• Used in memory-efficient applications like OS kernels, compilers, and real-time systems.

---

Types of Linked Lists

• Singly Linked List – Each node points to the next.
• Doubly Linked List – Nodes have next and previous pointers.
• Circular Linked List – The last node points back to the head.

---

Basic Structure of a Node

class Node:
    def __init__(self, data):
        self.data = data
        self.next = None

---

Building a Singly Linked List

class LinkedList:
    def __init__(self):
        self.head = None

    def append(self, data):
        new_node = Node(data)

        if not self.head:
            self.head = new_node
            return

        current = self.head
        while current.next:
            current = current.next
        current.next = new_node

---

Traversing the List

def display(self):
    current = self.head
    while current:
        print(current.data, end=" -> ")
        current = current.next
    print("None")

Usage:

ll = LinkedList()
ll.append(10)
ll.append(20)
ll.append(30)
ll.display()  # Output: 10 -> 20 -> 30 -> None

---

Inserting at the Beginning

def insert_at_beginning(self, data):
    new_node = Node(data)
    new_node.next = self.head
    self.head = new_node

---

Summary

• A singly linked list stores data as a sequence of nodes linked by references.

• Supports dynamic memory usage, fast insertions, and flexible resizing.

• The key is managing node connections safely and efficiently.

---

Exercise

• Implement a method length() that returns the number of nodes in the list.

---

#DataStructures #LinkedList #DSA #Python #CodingBasics

https://t.me/DataScience4

Topic: Linked Lists in Python – Part 2: Insertion, Deletion, and Search Operations

---

Recap from Part 1

• A singly linked list consists of nodes, where each node holds data and a pointer to the next node.

• We've implemented basic append and display functions.

Now we’ll explore insertion at specific positions, deletion, and searching.

---

1. Insert at a Specific Position

def insert_at_position(self, index, data):
    if index < 0:
        raise IndexError("Index cannot be negative")
    
    new_node = Node(data)
    
    if index == 0:
        new_node.next = self.head
        self.head = new_node
        return

    current = self.head
    for _ in range(index - 1):
        if not current:
            raise IndexError("Index out of bounds")
        current = current.next
    
    new_node.next = current.next
    current.next = new_node

---

2. Delete a Node by Value

def delete_by_value(self, value):
    if not self.head:
        return

    if self.head.data == value:
        self.head = self.head.next
        return

    current = self.head
    while current.next and current.next.data != value:
        current = current.next

    if current.next:
        current.next = current.next.next

---

3. Delete a Node by Index

def delete_by_index(self, index):
    if index < 0:
        raise IndexError("Index cannot be negative")

    if not self.head:
        raise IndexError("List is empty")

    if index == 0:
        self.head = self.head.next
        return

    current = self.head
    for _ in range(index - 1):
        if not current.next:
            raise IndexError("Index out of bounds")
        current = current.next

    if current.next:
        current.next = current.next.next

---

4. Search for an Element

def search(self, value):
    current = self.head
    index = 0
    while current:
        if current.data == value:
            return index
        current = current.next
        index += 1
    return -1  # Not found

---

5. Complete Class with All Methods

class LinkedList:
    def __init__(self):
        self.head = None

    def append(self, data): ...
    def display(self): ...
    def insert_at_position(self, index, data): ...
    def delete_by_value(self, value): ...
    def delete_by_index(self, index): ...
    def search(self, value): ...

*(You can reuse the method definitions above.)*

---

Summary

• You can manipulate linked lists with insertions and deletions at any position.

• Searching through a singly linked list is O(n).

• Always check for edge cases: empty list, index bounds, and duplicates.

---

Exercise

• Write a method reverse() that reverses the linked list in-place and test it on a list of 5+ elements.

---

#DSA #LinkedList #Python #Insertion #Deletion #Search

https://t.me/DataScience4

Topic: Linked Lists in Python – Part 3: Reversing, Detecting Loops, and Middle Node

---

In this part, we’ll explore advanced operations that are frequently asked in coding interviews using singly linked lists.

---

1. Reverse a Linked List (Iterative)

def reverse(self):
    prev = None
    current = self.head
    while current:
        next_node = current.next
        current.next = prev
        prev = current
        current = next_node
    self.head = prev

• Time Complexity: O(n)
• Space Complexity: O(1)

---

2. Find the Middle of the Linked List

• Use the slow and fast pointer approach.

def find_middle(self):
    slow = fast = self.head
    while fast and fast.next:
        slow = slow.next
        fast = fast.next.next
    return slow.data if slow else None

---

3. Detect a Loop in the Linked List

• Use Floyd’s Cycle Detection Algorithm (a.k.a. Tortoise and Hare).

def has_loop(self):
    slow = fast = self.head
    while fast and fast.next:
        slow = slow.next
        fast = fast.next.next
        if slow == fast:
            return True
    return False

---

4. Find the N-th Node from the End

def nth_from_end(self, n):
    first = self.head
    second = self.head

    for _ in range(n):
        if not first:
            return None
        first = first.next

    while first:
        first = first.next
        second = second.next

    return second.data

---

5. Full Example: Testing All Methods

ll = LinkedList()
for value in [10, 20, 30, 40, 50]:
    ll.append(value)

ll.display()
ll.reverse()
ll.display()
print("Middle:", ll.find_middle())
print("Has Loop?", ll.has_loop())
print("3rd from End:", ll.nth_from_end(3))

---

Summary

• Use pointer manipulation for efficient algorithms in linked lists.

• Common techniques:
• Fast/slow pointers
• Reversal by in-place re-linking
• Two-pointer gap approach for nth from end

---

Exercise

• Write a method is_palindrome() that checks if the linked list reads the same forwards and backwards (without converting it to a list or using extra space).

---

#DSA #LinkedList #ReverseList #LoopDetection #TwoPointerTechnique

https://t.me/DataScience4

Topic: Linked Lists in Python – Part 4: Merging, Sorting, and Advanced Interview Problems

---

In this final part of the Linked List series, we’ll tackle more advanced and practical use cases like merging sorted lists, sorting a linked list, and interview-level challenges.

---

1. Merging Two Sorted Linked Lists

def merge_sorted_lists(l1, l2):
    dummy = Node(0)
    tail = dummy

    while l1 and l2:
        if l1.data < l2.data:
            tail.next = l1
            l1 = l1.next
        else:
            tail.next = l2
            l2 = l2.next
        tail = tail.next

    tail.next = l1 or l2
    return dummy.next

---

2. Sorting a Linked List (Merge Sort – O(n log n))

def merge_sort(head):
    if not head or not head.next:
        return head

    # Split list
    slow, fast = head, head.next
    while fast and fast.next:
        slow = slow.next
        fast = fast.next.next

    mid = slow.next
    slow.next = None

    left = merge_sort(head)
    right = merge_sort(mid)

    return merge_sorted_lists(left, right)

• Attach this to your LinkedList class to sort self.head.

---

3. Removing Duplicates from a Sorted List

def remove_duplicates(self):
    current = self.head
    while current and current.next:
        if current.data == current.next.data:
            current.next = current.next.next
        else:
            current = current.next

---

4. Intersection Point of Two Linked Lists

def get_intersection_node(headA, headB):
    if not headA or not headB:
        return None

    a, b = headA, headB
    while a != b:
        a = a.next if a else headB
        b = b.next if b else headA
    return a  # Can be None or the intersecting node

---

5. Flatten a Multilevel Linked List

Imagine a list where each node has next and child pointers. Recursively flatten:

def flatten(node):
    if not node:
        return None

    next_node = node.next
    if node.child:
        child_tail = flatten(node.child)
        node.next = node.child
        node.child = None
        child_tail.next = flatten(next_node)
        return child_tail if child_tail.next else child_tail
    else:
        node.next = flatten(next_node)
        return node

---

Summary

• You now know how to merge, sort, and deduplicate linked lists.

• Techniques like merge sort, two-pointer traversal, and recursive flattening are essential for mastering linked lists.

• These problems are frequently asked in interviews at top tech companies.

---

Exercise

• Given two unsorted linked lists, write a function that returns a new linked list containing only the elements present in both lists (intersection), without using extra space or sets.

---

#DSA #LinkedList #MergeSort #AdvancedDSA #CodingInterview

https://t.me/DataScience4