Forem: Lokeshwaran S

Users, Roles and Groups in SQL - CA33

Lokeshwaran S — Sun, 29 Mar 2026 13:21:43 +0000

My Thinking and Approach

Introduction

In this task, I worked with roles and permissions in SQL using the dvdrental database. The goal was to control access to different tables by creating roles, assigning privileges, and managing user groups.

This helped me understand how database security works in real-world applications.

Problem Statement

Create roles with limited access
Grant and revoke permissions
Restrict access to specific columns
Manage users using groups

My Initial Thought

At first, I thought:

Roles are just users
Permissions are simple

But I realized:

Roles control access at different levels
Permissions can be very specific
Security is very important in databases

Key Observation

GRANT is used to give permissions
REVOKE is used to remove permissions
Roles can be grouped for easier management
Column-level access is possible

Solutions

Task 1: Create report_user with access to film table

CREATE ROLE report_user WITH LOGIN PASSWORD 'password';

GRANT SELECT ON film TO report_user;

Explanation:

Creates a login role
Allows only read access to film table

Task 2: Fix access to customer table

GRANT SELECT ON customer TO report_user;

Explanation:

Grants permission to read customer table

Task 3: Restrict columns in customer table

REVOKE SELECT ON customer FROM report_user;

GRANT SELECT (customer_id, first_name, last_name) ON customer TO report_user;

Explanation:

Removes full access
Grants access only to specific columns

Task 4: Create support_user with limited permissions

CREATE ROLE support_user WITH LOGIN PASSWORD 'password';

GRANT SELECT ON customer TO support_user;

GRANT UPDATE (email) ON customer TO support_user;

Explanation:

Can view customer data
Can update only email column
No DELETE permission given

Task 5: Remove film access from report_user

REVOKE SELECT ON film FROM report_user;

Explanation:

Removes access to film table

Task 6: Create readonly_group

CREATE ROLE readonly_group;

GRANT SELECT ON ALL TABLES IN SCHEMA public TO readonly_group;

Explanation:

Group with read-only access
Applies to all tables

Task 7: Create users and assign to group

CREATE ROLE analyst1 WITH LOGIN PASSWORD 'password';
CREATE ROLE analyst2 WITH LOGIN PASSWORD 'password';

GRANT readonly_group TO analyst1;
GRANT readonly_group TO analyst2;

Explanation:

Creates two users
Adds them to readonly group

Final Understanding

Roles help in managing permissions efficiently
Access can be controlled at table and column level
Groups simplify permission management for multiple users

Conclusion

This task helped me understand how to manage users, roles, and permissions in a database. It showed how important access control is for maintaining data security and integrity.

Filter Assignments - CA32

Lokeshwaran S — Sun, 29 Mar 2026 13:19:20 +0000

My Thinking and Approach

Introduction

In this bonus task, I explored advanced filtering techniques in SQL using the dvdrental database. The focus was on using conditions like NULL checks, pattern matching, ranges, and logical operators.

This helped me understand how to extract specific and meaningful data from a database.

Problem Statement

Retrieve data using conditions
Use operators like AND, OR, BETWEEN, IN
Apply pattern matching using LIKE
Work with LIMIT and OFFSET

My Initial Thought

At first, I thought:

Filtering is just using WHERE clause
Conditions are simple

But I realized:

SQL provides many ways to filter data
Pattern matching is very powerful
Combining conditions gives precise results

Key Observation

NULL values require special handling
LIKE is used for pattern matching
BETWEEN is useful for ranges
LIMIT and OFFSET control output size

Solutions

1. Movies with NULL special features

SELECT *
FROM film
WHERE special_features IS NULL;

2. Movies with rental duration more than 7

SELECT *
FROM film
WHERE rental_duration > 7;

3. Movies with rental rate 4.99 and replacement cost > 20

SELECT *
FROM film
WHERE rental_rate = 4.99 AND replacement_cost > 20;

4. Movies with rental rate 0.99 or rating PG-13

SELECT *
FROM film
WHERE rental_rate = 0.99 OR rating = 'PG-13';

5. First 5 movies sorted by title

SELECT *
FROM film
ORDER BY title ASC
LIMIT 5;

6. Skip 10 rows and fetch next 3 by replacement cost

SELECT *
FROM film
ORDER BY replacement_cost DESC
OFFSET 10
LIMIT 3;

7. Movies with rating G, PG, or PG-13

SELECT *
FROM film
WHERE rating IN ('G', 'PG', 'PG-13');

8. Movies with rental rate between 2 and 4

SELECT *
FROM film
WHERE rental_rate BETWEEN 2 AND 4;

9. Movies starting with The

SELECT *
FROM film
WHERE title LIKE 'The%';

10. First 10 movies with multiple conditions

SELECT *
FROM film
WHERE (rental_rate = 2.99 OR rental_rate = 4.99)
AND rating = 'R'
AND title LIKE '%Love%'
LIMIT 10;

11. Movies containing % symbol

SELECT *
FROM film
WHERE title LIKE '%\%%' ESCAPE '\';

12. Movies containing underscore

SELECT *
FROM film
WHERE title LIKE '%\_%' ESCAPE '\';

13. Titles starting with A or B and ending with s

SELECT *
FROM film
WHERE (title LIKE 'A%s' OR title LIKE 'B%s');

14. Movies containing Man, Men, or Woman

SELECT *
FROM film
WHERE title LIKE '%Man%' OR title LIKE '%Men%' OR title LIKE '%Woman%';

15. Movies containing digits

SELECT *
FROM film
WHERE title ~ '[0-9]';

16. Movies containing backslash

SELECT *
FROM film
WHERE title LIKE '%\\%';

17. Movies containing Love or Hate

SELECT *
FROM film
WHERE title LIKE '%Love%' OR title LIKE '%Hate%';

18. First 5 movies ending with er, or, ar

SELECT *
FROM film
WHERE title LIKE '%er' OR title LIKE '%or' OR title LIKE '%ar'
LIMIT 5;

Final Understanding

SQL filtering can be very precise using conditions
Pattern matching helps in text-based searches
Combining operators gives better control over results

Conclusion

This task helped me understand advanced SQL filtering techniques. It improved my ability to work with real-world data and extract meaningful information using different conditions.

Select Queries from DVD Rental Database - CA31

Lokeshwaran S — Sun, 29 Mar 2026 13:12:35 +0000

My Thinking and Approach

Introduction

In this task, I worked with the dvdrental database to practice SQL queries. The focus was on retrieving, sorting, and formatting data using different SQL clauses.

This helped me improve my understanding of SELECT, ORDER BY, DISTINCT, and column aliasing.

Problem Statement

Retrieve specific data from tables
Use aliases for better readability
Apply sorting using ORDER BY
Extract unique values using DISTINCT

My Initial Thought

At first, I thought:

Queries are just simple SELECT statements
Sorting is straightforward

But I realized:

Proper formatting improves readability
Sorting can involve multiple conditions
DISTINCT is useful for unique data

Key Observation

Aliases help make output user-friendly
ORDER BY can sort using multiple columns
DISTINCT removes duplicate values
Combining clauses makes queries powerful

Solutions

1. Film titles and rental rates

SELECT title AS "Movie Title", rental_rate AS "Rate"
FROM film;

2. Customer names and email

SELECT first_name AS "First Name", last_name AS "Last Name", email
FROM customer;

3. Films sorted by rental rate and title

SELECT title, rental_rate
FROM film
ORDER BY rental_rate DESC, title ASC;

4. Actor names sorted

SELECT first_name, last_name
FROM actor
ORDER BY last_name ASC, first_name ASC;

5. Unique replacement costs

SELECT DISTINCT replacement_cost
FROM film;

6. Film title and duration

SELECT title, length AS "Duration (min)"
FROM film;

7. Customer active status

SELECT first_name, last_name, active AS "Is Active"
FROM customer;

8. Film categories sorted

SELECT name
FROM category
ORDER BY name ASC;

9. Films by length descending

SELECT title, length
FROM film
ORDER BY length DESC;

10. Actors sorted by first name descending

SELECT first_name, last_name
FROM actor
ORDER BY first_name DESC;

11. Unique ratings

SELECT DISTINCT rating
FROM film;

12. Unique rental durations

SELECT DISTINCT rental_duration
FROM film;

13. First unique customer by active status

SELECT DISTINCT customer_id, active
FROM customer
ORDER BY customer_id;

14. Earliest rental date per customer

SELECT customer_id, MIN(rental_date) AS rental_date
FROM rental
GROUP BY customer_id
ORDER BY customer_id;

15. 10 shortest films

SELECT title, length
FROM film
ORDER BY length ASC
LIMIT 10;

16. Top 5 customers with highest ID

SELECT first_name, last_name
FROM customer
ORDER BY customer_id DESC
LIMIT 5;

17. Unique store IDs

SELECT DISTINCT store_id
FROM inventory;

18. Unique replacement cost sorted

SELECT DISTINCT replacement_cost
FROM film
ORDER BY replacement_cost ASC;

19. First rental date per store

SELECT store_id, MIN(rental_date) AS rental_date
FROM rental
GROUP BY store_id
ORDER BY store_id;

20. Unique film ratings sorted

SELECT DISTINCT rating
FROM film
ORDER BY rating ASC;

21. Films sorted by rating and length

SELECT title, rating, length
FROM film
ORDER BY rating ASC, length DESC;

22. Actor names with mixed sorting

SELECT first_name, last_name
FROM actor
ORDER BY last_name ASC, first_name DESC;

23. Films by replacement cost and rental rate

SELECT title, replacement_cost, rental_rate
FROM film
ORDER BY replacement_cost ASC, rental_rate DESC;

24. Customer names sorted

SELECT first_name, last_name
FROM customer
ORDER BY last_name ASC, first_name DESC;

25. Rentals sorted

SELECT *
FROM rental
ORDER BY customer_id ASC, rental_date DESC;

26. Films by rental duration and title

SELECT title, rental_duration
FROM film
ORDER BY rental_duration ASC, title DESC;

Final Understanding

SQL queries can be combined to perform powerful operations
Sorting and filtering improve data usability
Aliasing makes output more readable

Conclusion

This task helped me strengthen my SQL fundamentals by working with real-world queries on the dvdrental database. It improved my ability to retrieve, organize, and present data effectively.

Create Table in SQL - CA39

Lokeshwaran S — Sun, 29 Mar 2026 13:03:51 +0000

My Thinking and Approach

Introduction

In this task, I focused on creating database tables using SQL. Instead of modifying existing tables, the goal here was to define new tables with proper structure and constraints.

This helped me understand how to design tables in a way that ensures data consistency and integrity.

Problem Statement

Create tables with appropriate columns
Apply constraints like PRIMARY KEY, NOT NULL, UNIQUE, CHECK
Define default values
Establish relationships using foreign keys

My Initial Thought

At first, I thought:

Creating tables is just defining columns
Constraints are optional

But I realized:

Constraints are important for maintaining correct data
Table design plays a major role in database performance

Key Observation

PRIMARY KEY uniquely identifies each record
NOT NULL ensures required fields are filled
UNIQUE prevents duplicate values
CHECK enforces conditions
FOREIGN KEY maintains relationships

Solutions

1. Create students table

Code (SQL)

CREATE TABLE students (
    id INT PRIMARY KEY,
    name VARCHAR(100),
    age INT
);

Explanation:

id uniquely identifies each student
PRIMARY KEY ensures uniqueness

2. Create employees table

Code (SQL)

CREATE TABLE employees (
    name VARCHAR(100) NOT NULL,
    email VARCHAR(100) NOT NULL,
    phone_number VARCHAR(15)
);

Explanation:

name and email cannot be null
phone_number is optional

3. Create users table with unique fields

Code (SQL)

CREATE TABLE users (
    username VARCHAR(50) UNIQUE,
    email VARCHAR(100) UNIQUE
);

Explanation:

username and email must be unique

4. Create products table with conditions

Code (SQL)

CREATE TABLE products (
    price DECIMAL(10,2) CHECK (price > 0),
    stock INT CHECK (stock >= 0)
);

Explanation:

price must be greater than 0
stock cannot be negative

5. Create orders table with defaults

Code (SQL)

CREATE TABLE orders (
    status VARCHAR(20) DEFAULT 'pending',
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

Explanation:

status defaults to pending
created_at stores current time automatically

6. Create accounts table

Code (SQL)

CREATE TABLE accounts (
    account_number VARCHAR(20) NOT NULL UNIQUE,
    balance DECIMAL(10,2) CHECK (balance >= 0)
);

Explanation:

account_number must be unique and not null
balance must be non-negative

7. Create enrollments table with composite key

Code (SQL)

CREATE TABLE enrollments (
    student_id INT,
    course_id INT,
    UNIQUE (student_id, course_id)
);

Explanation:

combination of student_id and course_id must be unique

8. Create departments and employees with foreign key

Code (SQL)

CREATE TABLE departments (
    id INT PRIMARY KEY,
    name VARCHAR(100)
);

CREATE TABLE employees (
    id INT PRIMARY KEY,
    name VARCHAR(100),
    department_id INT,
    FOREIGN KEY (department_id) REFERENCES departments(id)
);

Explanation:

department_id must exist in departments table

9. Foreign key with cascade actions

Code (SQL)

CREATE TABLE departments (
    id INT PRIMARY KEY,
    name VARCHAR(100)
);

CREATE TABLE employees (
    id INT PRIMARY KEY,
    name VARCHAR(100),
    department_id INT,
    FOREIGN KEY (department_id)
    REFERENCES departments(id)
    ON DELETE CASCADE
    ON UPDATE CASCADE
);

Explanation:

deleting a department removes related employees
updating department id updates employee records

Final Understanding

Table creation is not just structure, it includes rules
Constraints ensure valid and consistent data
Relationships connect multiple tables effectively

Conclusion

This task helped me understand how to design tables properly with constraints and relationships. It also showed how important planning is while creating a database structure.

Alter Tables in SQL - CA40

Lokeshwaran S — Sun, 29 Mar 2026 13:01:05 +0000

My Thinking and Approach

Introduction

In this task, I worked on modifying existing database tables using ALTER TABLE statements. Instead of creating new tables, the goal was to update the structure of already existing tables by adding constraints, modifying columns, and enforcing rules.

This helped me understand how databases can be controlled and maintained properly.

Problem Statement

Modify existing tables using ALTER statements
Apply constraints like NOT NULL, UNIQUE, CHECK
Set default values
Manage foreign key behavior

My Initial Thought

At first, I thought:

ALTER TABLE is only used to add columns
Changes might be complicated

But I realized:

It can modify constraints as well
It is very useful for maintaining data integrity

Key Observation

Constraints help in controlling data
ALTER TABLE allows updating structure without deleting data
Each modification must be carefully applied

Solutions

1. Make email NOT NULL in customers table

Code (SQL)

ALTER TABLE customers
MODIFY email VARCHAR(255) NOT NULL;

Explanation:

Ensures email cannot be empty in future records

2. Make username UNIQUE in users table

Code (SQL)

ALTER TABLE users
ADD CONSTRAINT unique_username UNIQUE (username);

Explanation:

Prevents duplicate usernames

3. Ensure price is greater than 0 in products table

Code (SQL)

ALTER TABLE products
ADD CONSTRAINT check_price CHECK (price > 0);

Explanation:

Ensures valid product pricing

4. Set default value for status in orders table

Code (SQL)

ALTER TABLE orders
ALTER COLUMN status SET DEFAULT 'pending';

Explanation:

Automatically assigns pending if no value is given

5. Add salary column with constraints in employees table

Code (SQL)

ALTER TABLE employees
ADD salary INT NOT NULL CHECK (salary > 10000);

Explanation:

Adds salary column
Ensures it is not null
Ensures salary is greater than 10000

6. Modify foreign key with cascade delete

Code (SQL)

ALTER TABLE employees
ADD CONSTRAINT fk_department
FOREIGN KEY (department_id)
REFERENCES departments(id)
ON DELETE CASCADE;

Explanation:

Deletes employees automatically when department is deleted

7. Remove CHECK constraint from accounts table

Code (SQL)

ALTER TABLE accounts
DROP CONSTRAINT check_balance;

Explanation:

Removes restriction on balance

8. Make user_id and transaction_id unique in payments table

Code (SQL)

ALTER TABLE payments
ADD CONSTRAINT unique_payment UNIQUE (user_id, transaction_id);

Explanation:

Ensures no duplicate transactions per user

Final Understanding

ALTER TABLE is powerful for modifying structure
Constraints help maintain clean and valid data
Proper use of constraints improves database reliability

Conclusion

This task helped me understand how to control and update database tables efficiently without recreating them. It also improved my understanding of constraints and their importance in real-world applications.

Number Guessing Game - CA03

Lokeshwaran S — Sun, 22 Mar 2026 15:36:30 +0000

Objective

Retrieve leaderboard records from the database
Arrange records based on difficulty level and number of attempts

Data Structure

Each record in the leaderboard contains:

Name
Difficulty level
Attempts count

Approach

Collect all leaderboard entries
Convert difficulty levels into comparable values
Apply sorting logic using both difficulty and attempts

Difficulty Priority

To ensure proper ordering:

Easy is considered lowest
Medium is next
Hard is highest

This helps in comparing difficulty levels during sorting.

Sorting Logic

Compare two entries
First check difficulty level
If difficulty is same, compare attempts
Swap positions if required
Repeat until the list is sorted

Code (Python)

```python id="lb32x1"
leaderboard = [
{"name": "Alice", "difficulty": "Medium", "attempts": 5},
{"name": "Bob", "difficulty": "Easy", "attempts": 3},
{"name": "Charlie", "difficulty": "Hard", "attempts": 7},
{"name": "David", "difficulty": "Easy", "attempts": 6}
]

difficulty_rank = {"Easy": 1, "Medium": 2, "Hard": 3}

for i in range(len(leaderboard)):
for j in range(len(leaderboard) - i - 1):

    current = leaderboard[j]
    next_item = leaderboard[j + 1]

    if (difficulty_rank[current["difficulty"]] > difficulty_rank[next_item["difficulty"]]) or \
       (difficulty_rank[current["difficulty"]] == difficulty_rank[next_item["difficulty"]] and
        current["attempts"] > next_item["attempts"]):

        leaderboard[j], leaderboard[j + 1] = leaderboard[j + 1], leaderboard[j]

for item in leaderboard:
print(item)




---

## Explanation

* Leaderboard data is stored using dictionaries
* Difficulty values are mapped to numbers for comparison
* Sorting is done using two conditions

  * First by difficulty
  * Then by attempts if difficulty is same
* Bubble sort ensures correct ordering step by step

---

## Example

Input:

* Alice, Medium, 5
* Bob, Easy, 3
* Charlie, Hard, 7
* David, Easy, 6

Output:

* Bob, Easy, 3
* David, Easy, 6
* Alice, Medium, 5
* Charlie, Hard, 7

---

## Conclusion

This implementation ensures that leaderboard data is organized clearly based on difficulty and performance. It improves readability and helps users understand rankings effectively.

Different Sorting Methodologies - CA17

Lokeshwaran S — Sun, 22 Mar 2026 15:31:32 +0000

My Thinking and Approach

Introduction

In this session, I learned different sorting algorithms that are used to arrange data in a specific order.

Sorting is important because it helps in organizing data and improving efficiency in searching.

Problem Statement

Understand different sorting techniques
Learn how each algorithm works
Analyze their performance

My Initial Thought

At first, I thought:

Sorting is simple arrangement
All methods work similarly

But I realized:

Each algorithm has a different approach
Efficiency varies

Key Observation

Some algorithms are easy but slow
Some are complex but efficient
Choice depends on problem size

Sorting Methodologies

1. Bubble Sort

Logic:

Compare adjacent elements
Swap if they are in wrong order

Code (Python)

```python id="bub12"
def bubble_sort(arr):
n = len(arr)

for i in range(n):
    for j in range(0, n - i - 1):
        if arr[j] > arr[j + 1]:
            arr[j], arr[j + 1] = arr[j + 1], arr[j]

return arr




Explanation:

* Repeatedly compares adjacent elements
* After each pass, largest element moves to the end

---

### 2. Selection Sort

### Logic:

* Find minimum element
* Place it at correct position

### Code (Python)



```python id="sel34"
def selection_sort(arr):
    n = len(arr)

    for i in range(n):
        min_index = i

        for j in range(i + 1, n):
            if arr[j] < arr[min_index]:
                min_index = j

        arr[i], arr[min_index] = arr[min_index], arr[i]

    return arr

Explanation:

Selects smallest element
Swaps with current index
Builds sorted part step by step

3. Insertion Sort

Logic:

Insert each element in correct position

Code (Python)

```python id="ins56"
def insertion_sort(arr):
for i in range(1, len(arr)):
key = arr[i]
j = i - 1

    while j >= 0 and arr[j] > key:
        arr[j + 1] = arr[j]
        j -= 1

    arr[j + 1] = key

return arr




Explanation:

* Takes one element at a time
* Places it in correct position in sorted part

---

### 4. Merge Sort

### Logic:

* Divide array
* Sort halves
* Merge

### Code (Python)



```python id="mer78"
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

Explanation:

Divides array recursively
Merges sorted halves
Efficient for large data

5. Quick Sort

Logic:

Choose pivot
Partition array
Recursively sort

Code (Python)

```python id="qui90"
def quick_sort(arr):
if len(arr) <= 1:
return arr

pivot = arr[len(arr) // 2]

left = [x for x in arr if x < pivot]
middle = [x for x in arr if x == pivot]
right = [x for x in arr if x > pivot]

return quick_sort(left) + middle + quick_sort(right)




Explanation:

* Divides array based on pivot
* Recursively sorts parts
* Faster in practice

---

## Complexity Analysis

| Algorithm      | Time Complexity |
| -------------- | --------------- |
| Bubble Sort    | O(n²)           |
| Selection Sort | O(n²)           |
| Insertion Sort | O(n²)           |
| Merge Sort     | O(n log n)      |
| Quick Sort     | O(n log n)      |

---

## Key Takeaways

* Sorting algorithms differ in efficiency
* Simple methods are easier but slower
* Advanced methods improve performance
* Choosing correct algorithm is important

---

## Conclusion

This session helped me understand different sorting methodologies and how to choose the right one based on the problem.

---

Merge Two Sorted Lists - CA15

Lokeshwaran S — Sun, 22 Mar 2026 15:24:19 +0000

My Thinking and Approach

Introduction

In this problem, I was given two sorted linked lists and asked to merge them into a single sorted linked list.

The final list should also be sorted.

Problem Statement

Given two sorted linked lists list1 and list2
Merge them into one sorted linked list
Return the head of the merged list
Conditions:
- Use existing nodes
- Maintain sorted order

My Initial Thought

At first, I considered:

Converting both lists into arrays
Merging arrays
Rebuilding the linked list

But this approach uses extra space.

Key Observation

Since both lists are already sorted:

I can compare nodes one by one
Attach the smaller node to the result

Optimized Approach

I decided to merge the lists using pointer manipulation.

Logic:

Compare current nodes of both lists
Attach smaller node to result
Move forward in that list

My Approach (Step-by-Step)

Create a dummy node
Use a pointer curr for result list
While both lists are not empty:

Compare values
Attach smaller node
Move pointer forward

Attach remaining nodes of any list
Return dummy.next

Code (Python)

Below is the implementation clearly separated inside a code block:

```python id="k4p9zs"
class ListNode:
def init(self, val=0, next=None):
self.val = val
self.next = next

class Solution:
def mergeTwoLists(self, list1, list2):
dummy = ListNode()
curr = dummy

    while list1 and list2:
        if list1.val <= list2.val:
            curr.next = list1
            list1 = list1.next
        else:
            curr.next = list2
            list2 = list2.next
        curr = curr.next

    if list1:
        curr.next = list1
    else:
        curr.next = list2

    return dummy.next




---

## Example Walkthrough

### Input:



```text id="x2n9rf"
list1 = [1, 2, 4], list2 = [1, 3, 4]

Steps:

Compare nodes and attach smaller values
Continue until one list ends
Attach remaining elements

Output:

```text id="v5k3qp"
[1, 1, 2, 3, 4, 4]




---

## Complexity Analysis

| Type             | Complexity |
| ---------------- | ---------- |
| Time Complexity  | O(n + m)   |
| Space Complexity | O(1)       |

---

## Key Takeaways

* Two pointer technique is effective
* No extra space required
* Dummy node simplifies implementation

---

## Conclusion

This problem helped me understand how to efficiently merge two sorted linked lists using pointer manipulation.

---

Merge Sort for Linked List - CA24

Lokeshwaran S — Sun, 22 Mar 2026 15:20:22 +0000

My Thinking and Approach

Introduction

In this problem, I was given the head of a linked list and asked to sort it using Merge Sort.

Merge Sort is efficient for linked lists because it does not require random access like arrays.

Problem Statement

Given the head of a linked list
Sort the linked list using Merge Sort
Return the sorted list

My Initial Thought

At first, I considered:

Converting the linked list into an array
Sorting the array
Rebuilding the linked list

But this approach uses extra space.

Key Observation

Merge Sort works well with linked lists because:

We can split the list into halves easily
We can merge sorted lists efficiently

Optimized Approach

I decided to use Merge Sort with recursion.

Logic:

Divide the list into two halves
Recursively sort both halves
Merge the sorted halves

My Approach (Step-by-Step)

Base Case:

If list is empty or has one node → return head

Find middle of list:

Use slow and fast pointer

Split the list into two halves
Recursively sort both halves
Merge the two sorted lists

Code (Python)

Below is the implementation clearly separated inside a code block:

```python id="m7x4qp"
class Node:
def init(self, data):
self.data = data
self.next = None

class Solution:
def mergeSort(self, head):
if not head or not head.next:
return head

    mid = self.getMiddle(head)
    next_to_mid = mid.next
    mid.next = None

    left = self.mergeSort(head)
    right = self.mergeSort(next_to_mid)

    return self.sortedMerge(left, right)

def getMiddle(self, head):
    slow = head
    fast = head.next

    while fast and fast.next:
        slow = slow.next
        fast = fast.next.next

    return slow

def sortedMerge(self, left, right):
    if not left:
        return right
    if not right:
        return left

    if left.data <= right.data:
        result = left
        result.next = self.sortedMerge(left.next, right)
    else:
        result = right
        result.next = self.sortedMerge(left, right.next)

    return result




---

## Example Walkthrough

### Input:



```text id="v9q1kz"
10 -> 30 -> 20 -> 40 -> 50 -> 60

Steps:

Split into halves
Sort each half recursively
Merge sorted halves

Output:

```text id="g6x2we"
10 -> 20 -> 30 -> 40 -> 50 -> 60




---

## Complexity Analysis

| Type             | Complexity |
| ---------------- | ---------- |
| Time Complexity  | O(n log n) |
| Space Complexity | O(log n)   |

---

## Key Takeaways

* Merge Sort is efficient for linked lists
* Slow and fast pointers help in splitting
* Merging step is crucial

---

## Conclusion

This problem helped me understand how to apply merge sort on linked lists efficiently without using extra space for arrays.

---

Remove Duplicates from a Sorted Linked List - CA23

Lokeshwaran S — Sun, 22 Mar 2026 15:17:58 +0000

My Thinking and Approach

Introduction

In this problem, I was given a sorted singly linked list and asked to remove duplicate nodes.

Since the list is sorted, duplicate values appear next to each other.

Problem Statement

Given the head of a sorted linked list
Remove duplicate nodes
Return the updated list
Conditions:
- Do not use extra space
- Maintain original order

My Initial Thought

At first, I considered:

Using a set to store values
Rebuilding the list with unique elements

But this approach uses extra space.

Key Observation

Because the list is sorted:

Duplicate elements are adjacent
I only need to compare current node with next node

Optimized Approach

I decided to traverse the list once and remove duplicates in-place.

Logic:

If current node value equals next node value → skip the next node
Else → move forward

My Approach (Step-by-Step)

Start with curr = head
Traverse while curr and curr.next exist
At each step:

If curr.data == curr.next.data → remove duplicate → curr.next = curr.next.next
Else → move to next node

Code (Python)

Below is the implementation clearly separated inside a code block:

```python id="k9f2xw"
class Node:
def init(self, data):
self.data = data
self.next = None

class Solution:
def removeDuplicates(self, head):
curr = head

    while curr and curr.next:
        if curr.data == curr.next.data:
            curr.next = curr.next.next
        else:
            curr = curr.next

    return head




---

## Example Walkthrough

### Input:



```text id="x6p3lm"
2 -> 2 -> 4 -> 5

Steps:

Compare 2 and 2 → remove duplicate
Move forward and compare remaining nodes

Output:

```text id="r2g7zs"
2 -> 4 -> 5




---

## Complexity Analysis

| Type             | Complexity |
| ---------------- | ---------- |
| Time Complexity  | O(n)       |
| Space Complexity | O(1)       |

---

## Key Takeaways

* Sorted property simplifies the problem
* No extra space is required
* Pointer manipulation is important

---

## Conclusion

This problem helped me understand how to efficiently remove duplicates from a linked list using in-place operations.

---

Reverse a Linked List - CA22

Lokeshwaran S — Sun, 22 Mar 2026 15:14:28 +0000

My Thinking and Approach

Introduction

In this problem, I was given the head of a linked list and asked to reverse the list.

After reversing, I need to return the new head of the linked list.

Problem Statement

Given the head of a linked list
Reverse the linked list
Return the new head

My Initial Thought

At first, I considered:

Storing elements in an array
Reversing the array
Rebuilding the linked list

But this approach uses extra space.

Key Observation

Instead of using extra space:

I can reverse the links between nodes
Change the direction of pointers

Optimized Approach

I decided to reverse the list using pointer manipulation.

Logic:

Keep track of previous, current, and next nodes
Reverse the link at each step

My Approach (Step-by-Step)

Initialize:

prev = None
curr = head

Traverse the list:

Store next node
Reverse current node link
Move prev and curr forward

At the end:

prev will be the new head

Code (Python)

Below is the implementation clearly separated inside a code block:

```python id="8x3q1n"
class ListNode:
def init(self, val=0, next=None):
self.val = val
self.next = next

class Solution:
def reverseList(self, head):
prev = None
curr = head

    while curr:
        next_node = curr.next
        curr.next = prev
        prev = curr
        curr = next_node

    return prev




---

## Example Walkthrough

### Input:



```text id="z4s8mk"
1 -> 2 -> 3 -> 4 -> 5

Steps:

Reverse links one by one
Final list becomes reversed

Output:

```text id="b0h9pe"
5 -> 4 -> 3 -> 2 -> 1




---

## Complexity Analysis

| Type             | Complexity |
| ---------------- | ---------- |
| Time Complexity  | O(n)       |
| Space Complexity | O(1)       |

---

## Key Takeaways

* Pointer manipulation is important in linked lists
* No extra space is required
* Iterative approach is efficient

---

## Conclusion

This problem helped me understand how to reverse a linked list efficiently using pointer manipulation.

---

Majority Element - CA21

Lokeshwaran S — Sun, 22 Mar 2026 15:10:58 +0000

My Thinking and Approach

Introduction

In this problem, I was given an array and asked to find the majority element.

A majority element is one that appears more than n/2 times in the array.

Problem Statement

Given an array arr
Find the element that appears more than n/2 times
If no such element exists:
- Return -1

My Initial Thought

At first, I considered:

Using a hashmap to count frequencies
Returning the element with highest count

But this approach uses extra space.

Key Observation

There can be at most one majority element.

This allows a more optimized approach without extra space.

Optimized Approach

I decided to use Moore’s Voting Algorithm.

Logic:

Maintain a candidate and count
Increase count if same element appears
Decrease count if different element appears
Final candidate may be majority

My Approach (Step-by-Step)

Initialize:

candidate = None
count = 0

Traverse array:

If count == 0: → set candidate = current element
If element == candidate: → count += 1
Else: → count -= 1

Verify candidate:

Count occurrences of candidate
If count > n/2 → return candidate
Else → return -1

Code (Python)

Below is the implementation clearly separated inside a code block:

```python id="y3sk9q"
class Solution:
def majorityElement(self, arr):
candidate = None
count = 0

    for num in arr:
        if count == 0:
            candidate = num
        if num == candidate:
            count += 1
        else:
            count -= 1

    count = 0
    for num in arr:
        if num == candidate:
            count += 1

    if count > len(arr) // 2:
        return candidate
    return -1




---

## Example Walkthrough

### Input:



```text id="l4u2qg"
arr = [1, 1, 2, 1, 3, 5, 1]

Steps:

Candidate becomes 1
Count stabilizes with majority
Verify count > n/2

Output:

```text id="qv6y2x"
1




---

## Complexity Analysis

| Type             | Complexity |
| ---------------- | ---------- |
| Time Complexity  | O(n)       |
| Space Complexity | O(1)       |

---

## Key Takeaways

* Only one majority element can exist
* Moore’s Voting Algorithm is optimal
* Verification step is important

---

## Conclusion

This problem helped me understand how to find the majority element efficiently using a constant space approach.

---