DEV Community: Suruthika

CA 32 - Filter Assignments

Suruthika — Mon, 30 Mar 2026 14:54:04 +0000

I started by retrieving all movies that have a rental rate greater than $3.

SELECT *
FROM film
WHERE rental_rate > 3;

Then I added multiple conditions. I got movies with rental rate greater than $3 and replacement cost less than $20.

SELECT *
FROM film
WHERE rental_rate > 3 AND replacement_cost < 20;

Next, I used OR condition retrieved movies that are either rated 'PG' or have a rental rate of $0.99.

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

I also worked with limit and sorting. I showed the first 10 movies sorted by highest rental rate.

SELECT *
FROM film
ORDER BY rental_rate DESC
LIMIT 10;

Then I used offset to skip rows. I skipped the first 5 movies and fetched the next 3 in ascending order.

SELECT *
FROM film
ORDER BY rental_rate ASC
LIMIT 3 OFFSET 5;

I retrieved movies with rental duration between 3 and 7 days.

SELECT *
FROM film
WHERE rental_duration BETWEEN 3 AND 7;

I retrieved movies with rental duration more than 7 days.

SELECT *
FROM film
WHERE rental_duration > 7;

I used pattern matching to find titles starting with 'A' and ending with 'e'.

SELECT *
FROM film
WHERE title LIKE 'A%e';

I used pattern matching with or.

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

I searched titles containing specific words.

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

I searched actor names containing "man".

SELECT *
FROM actor
WHERE last_name LIKE '%man%';

I checked for NULL values by finding customers without an email.

SELECT *
FROM customer
WHERE email IS NULL;

I found movies where special features are NULL.

SELECT *
FROM film
WHERE special_features IS NULL;

I combined multiple conditions again. I found movies released in 2006 with rental rate 2.99 or 3.99 and title starting with 'S'.

SELECT title, rental_rate, release_year
FROM film
WHERE release_year = 2006
AND rental_rate IN (2.99, 3.99)
AND title LIKE 'S%'
LIMIT 5;

I combined multiple filters again with limit.

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

I retrieved rentals between two dates.

SELECT *
FROM rental
WHERE rental_date BETWEEN '2005-05-01' AND '2005-06-01';

I displayed 10 customers after skipping the first 20, sorted by last name.

SELECT *
FROM customer
ORDER BY last_name
LIMIT 10 OFFSET 20;

I got top movies by replacement cost while skipping the most expensive one.

SELECT *
FROM film
ORDER BY replacement_cost DESC
LIMIT 5 OFFSET 1;

CA 31 - Select Queries from DVD Rental database

Suruthika — Sun, 29 Mar 2026 18:22:42 +0000

I retrieved film titles and their rental rates. I used column aliases to make the output more readable. Instead of showing column names like title and rental_rate, I renamed them to "Movie Title" and "Rate".

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

Next, I listed customer names along with their email addresses. I renamed first_name and last_name to "First Name" and "Last Name".

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

I retrieved films sorted by rental rate in descending order. If two films had the same rental rate, I sorted them alphabetically by title.

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

I also sorted actor names by last name first and then by first name.

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

To understand unique values, I used DISTINCT. I listed all unique replacement costs and ratings from the film table.

SELECT DISTINCT replacement_cost
FROM film;

SELECT DISTINCT rating
FROM film
ORDER BY rating;

I also retrieved film titles along with their length and renamed the length column.

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

Then I checked customer details with their active status.

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

I explored categories and sorted them alphabetically.

SELECT name
FROM category
ORDER BY name;

I listed films by length in descending order.

SELECT title, length
FROM film
ORDER BY length DESC;

I also sorted actor names in reverse order based on first name.

SELECT first_name, last_name
FROM actor
ORDER BY first_name DESC;

To find unique rental durations, I used DISTINCT again.

SELECT DISTINCT rental_duration
FROM film;

I retrieved the first customer based on active status.

SELECT customer_id, active
FROM customer
ORDER BY customer_id
LIMIT 1;

I also retrieved the earliest rental date for each customer.

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

Next, I found the shortest films by length.

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

I retrieved the top 5 customers with the highest IDs.

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

I checked unique store IDs from the inventory table.

SELECT DISTINCT store_id
FROM inventory;

I also sorted replacement costs in ascending order.

SELECT DISTINCT replacement_cost
FROM film
ORDER BY replacement_cost;

Then I found the first rental date for each store.

SELECT i.store_id, MIN(r.rental_date) AS rental_date
FROM rental r
JOIN inventory i ON r.inventory_id = i.inventory_id
GROUP BY i.store_id
ORDER BY i.store_id;

I sorted films by rating and then by length.

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

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

I sorted films by replacement cost and rental rate.

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

I sorted customer names.

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

I sorted rentals.

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

Finally, I listed films sorted by rental duration and title.

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

CA 27 - Write a blog on how DNS resolver is happening.

Suruthika — Sun, 29 Mar 2026 17:57:24 +0000

I already tried to understand what really happens when I type a website into the browser. The browser shows the page instantly, but behind the scenes, there is a process called DNS resolution.

the first step is to check if the IP is already available locally. The browser checks cache. If the IP is found there the process stops.
If the IP is not found, the request goes to a component called the sub resolver in our system. This resolver sends the query to a main resolver, which is usually provided by ISP.
Now the main resolver takes finding the IP address. It start with the root name server. The root server directs the resolver to the correct TLD server based on the domain extension like .com, .org, .net.

The TLD again does not have the final IP but it points to the SLD name server for that specific domain. This SLD contains something called a zone file which holds the mapping of domain names to IP address. It also contains information about subdomains.Once the correct IP address is found, it is sent back to the MAIN resolver then to the sub resolver, and finally to my browser.

This whole DNS resolution process happens very quickly, usually in milliseconds tho there is a lot of process.

A 26 - Write a blog on "How a request originates from client and reaches the server ?"

Suruthika — Sun, 29 Mar 2026 17:47:35 +0000

I tried to understand what actually happens when I type a URL in the browser and press enter.

When I type a website like www.facebook.com the process starts from my system which acts as the client. The browser first needs to find the IP address of this domain because machines understand IP addresses only.

So the browser starts a DNS query. It first checks if the IP is already stored locally. If not, the request moves to the sub resolver. This sub resolver sends the query to a main resolver,

The main resolver now finds the IP address. It starts by contacting the root name server. The root server doesn’t know the IP, but it points to the TLD server. TLD stands for Top Level Domain, like .com, .org, etc.
the resolver contacts the TLD server. The TLD server responds with the sld which handles the specific domain (this is second level domain, like amazon).This server contains the zone file which has the mapping of domain names to IP address.

Once the IP address is found, it is sent back through the chain to my browser. Now the browser knows where to send the actual request.

After this, the browser sends an HTTP request to the server using that IP address. This request has different types. The GET which is used to fetch data like a webpage. POST is used to send data to the server. PUT is used to update data, PATCH is used to partially update data, and DELETE is used to remove data. a secure connection may be given using TLS (Transport Layer Security). This ensures that the data is encrypted and safe while traveling. This is what happens when we use HTTPS.

Finally, the request reaches the server. The server process the request and sends back a response which travels back to the browser. the webpage appears on the screen.

This entire process happens in just a few milliseconds.

CA 04 - Two Sum & Sorted Two Sum

Suruthika — Sun, 29 Mar 2026 17:09:23 +0000

TWO SUM PROBLEM

I solved the Two Sum problem from LeetCode in java using brute force method. The problem gives an array of integers and a target value. I need to find two indices so that the numbers at those indices add to the target. and i can't use the same element twice, and there will always be one valid answer.

To solve this, I used a simple method. I took one number from the array and compared it with every number that comes after it. For every pair i checked if their sum is equal to the target. If it is i need to return the indices of those two numbers.

I used two loops for this. The first loop picks one number, and the second loop checks the remaining numbers. As soon as it find a pair that matches the target, it return the answer.

This method works correctly but takes more time because it checks all pairs. The time complexity is O(n^2). The space complexity is O(1) because no extra space is used.

class Solution {
    public int[] twoSum(int[] nums, int target) {
        for(int i = 0; i < nums.length; i++) {
            for(int j = i + 1; j < nums.length; j++) {
                if(nums[i] + nums[j] == target) {
                    return new int[] {i, j};
                }
            }
        }
        return new int[] {};
    }
}

SORTED TWO SUM

The task is to find two numbers such that their sum equals the target and return their positions. I also need to add 1 to the indices before returning them.

To solve this, i used a simple brute force method. It checked every possible pair of numbers in the array and saw if their sum equals the target.

I used two loops for this. The first loop picks one number, and the second loop checks all the numbers after it. For each pair, It added the two numbers and compared the result with the target. If the sum matches, it return the indices. return i + 1 and j + 1.

class Solution {
    public int[] twoSum(int[] numbers, int target) {
        for(int i = 0; i < numbers.length; i++) {
            for(int j = i + 1; j < numbers.length; j++) {
                if(numbers[i] + numbers[j] == target) {
                    return new int[] {i + 1, j + 1};
                }
            }
        }
        return new int[] {};
    }
}

This method works correctly but it takes more time. The time complexity is O(n^2) because of the nested loops. The space complexity is O(1) since no extra space is used.

CA 16 - IP address and Subnet

Suruthika — Mon, 23 Mar 2026 15:51:01 +0000

An IP address is used to identify a device on a network. It like a home address but for computers. Every device connected to the network has a unique IP address so data can be sent and received correctly. For example, an IP address like 10.1.34.81 is IPv4. there is IPV6 but it is a failure model and not used right now.

An IP address is made up of two parts. One part represents the network part and the other part represents the host (for our device). This is where subnetting comes.

Subnet is dividing a large network into smaller networks. This helps in improved performance and also when the ip address is not enough. Instead of having one large network with many devices subnetting allows to split it into small groups.

A subnet mask decides which part of the IP address belongs to the network and which part belongs to the host.

CIDR is Classless Inter-Domain Routing. It is modern way of representing IP addresses and subnet masks. Instead of writing the subnet mask separately, CIDR combines it with the IP address using a slash.

For example, 10.1.34.81/24 means that the first 24 bits are used for the network. This is the same as the subnet mask

In CIDR, the number after the slash is how many bits are used for the network. A higher number means less hosts, and a lower number means more hosts. For example, /16 allows more devices than /24.

Finally, IP addresses help identify devices, subnetting helps divide networks into smaller parts, and CIDR represents these networks. These concepts are important for understanding how networks work.

CA 24 - Sort a Linked List using Merge Sort

Suruthika — Sun, 22 Mar 2026 18:28:16 +0000

Problem
Sort a Linked List using Merge Sort
You are given the head of a singly linked list.
Your task is to sort the linked list using Merge Sort.

Examples
Input: 60 → 50 → 40 → 30 → 20 → 10
Output: 10 → 20 → 30 → 40 → 50 → 60
Input: 9 → 5 → 2 → 8
Output: 2 → 5 → 8 → 9

Approach

Merge Sort works very well for linked lists because it does not require random access.

Steps:

Find the middle of the linked list (using slow and fast pointers)
Split the list into two halves
Recursively sort both halves
Merge the two sorted halves

This divide-and-conquer approach ensures efficient sorting.

Complexity:
Time Complexity: O(n log n)
Space Complexity: O(log n) (due to recursion)

class ListNode:
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next


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

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

    return slow


def merge(l1, l2):
    dummy = ListNode(0)
    tail = dummy

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

    tail.next = l1 if l1 else l2
    return dummy.next


def mergeSort(head):
    if not head or not head.next:
        return head
    mid = getMiddle(head)
    right = mid.next
    mid.next = None

    left = head

    left = mergeSort(left)
    right = mergeSort(right)

    return merge(left, right)
head = ListNode(9)
head.next = ListNode(5)
head.next.next = ListNode(2)
head.next.next.next = ListNode(8)

sorted_head = mergeSort(head)

curr = sorted_head
while curr:
    print(curr.val, end=" -> " if curr.next else "")
    curr = curr.next

CA 23 - Remove Duplicates in Sorted Linked List

Suruthika — Sun, 22 Mar 2026 18:25:38 +0000

Problem
Remove Duplicates in Sorted Linked List
You are given a sorted singly linked list.
Your task is to remove duplicate nodes, keeping only one occurrence of each element.

The solution should be done in-place with O(1) extra space.

Examples
Input: 2 → 2 → 4 → 5
Output: 2 → 4 → 5
Input: 2 → 2 → 2 → 2 → 2
Output: 2

Approach

Since the list is already sorted, duplicate values will always be adjacent.

Steps:

Traverse the list using a pointer curr
Compare the current node with the next node:
If they are equal → skip the next node (curr.next = curr.next.next)
Otherwise → move to the next node
Continue until the end of the list

This removes duplicates without using extra space.

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

class ListNode:
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = nex
def removeDuplicates(head):
    curr = head
    while curr and curr.next:
        if curr.val == curr.next.val:
            curr.next = curr.next.next
        else:
            curr = curr.next
    return head
head = ListNode(2)
head.next = ListNode(2)
head.next.next = ListNode(4)
head.next.next.next = ListNode(5)

new_head = removeDuplicates(head)

curr = new_head
while curr:
    print(curr.val, end=" -> " if curr.next else "")
    curr = curr.next

CA 22 - Reverse a Linked List

Suruthika — Sun, 22 Mar 2026 18:22:34 +0000

Problem
Reverse a Linked List
You are given the head of a singly linked list.
Your task is to reverse the linked list and return the new head.

Example
Input: 1 → 2 → 3 → 4
Output: 4 → 3 → 2 → 1

Approach

We reverse the linked list by changing the direction of the next pointers.

Steps:

Initialize three pointers:
prev = None
curr = head
Traverse the list:
Store the next node
Reverse the link (curr.next = prev)
Move prev and curr forward
At the end, prev will be the new head

This effectively flips the list in one pass.

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

class ListNode:
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next
def reverseList(head):
    prev = None
    curr = head
    while curr:
        next_node = curr.next
        curr.next = prev
        prev = curr
        curr = next_node
    return pre
head = ListNode(1)
head.next = ListNode(2)
head.next.next = ListNode(3)
head.next.next.next = ListNode(4)
reversed_head = reverseList(head)
curr = reversed_head
while curr:
    print(curr.val, end=" -> " if curr.next else "")
    curr = curr.next

CA 21 - Find the Majority Element

Suruthika — Sun, 22 Mar 2026 18:19:41 +0000

Problem
Find the Majority Element
You are given an array arr[].
Your task is to find the majority element in the array.

A majority element is one that appears more than n/2 times.
If no such element exists, return -1.

Input: [1, 1, 2, 1, 3, 5, 1] → Output: 1
Input: [7] → Output: 7
Input: [2, 13] → Output: -1

Approach

We use the Boyer-Moore Voting Algorithm, which finds a potential majority element in one pass
After this pass, we verify if the candidate actually appears more than n/2 times.

Steps:

Initialize candidate and count = 0
Traverse the array:
If count is 0 → set current element as candidate
If element equals candidate → increment count
Else → decrement count
Verify the candidate by counting its occurrences

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

def majorityElement(arr):
    candidate = None
    count = 0
    for num in arr:
        if count == 0:
            candidate = num
        count += (1 if num == candidate else -1)
    if arr.count(candidate) > len(arr) // 2:
        return candidate
    else:
        return -1
arr = [1, 1, 2, 1, 3, 5, 1]
print(majorityElement(arr))

CA 20 - Search in Rotated Sorted Array

Suruthika — Sun, 22 Mar 2026 18:17:04 +0000

Problem
Search in Rotated Sorted Array
You are given a sorted array nums[] with distinct elements, but it may be rotated at an unknown index.

Your task is to find the index of a given target.
If the target is not present, return -1.

You must solve this in O(log n) time.

Input: nums = [4,5,6,7,0,1,2], target = 0 → Output: 4
Input: nums = [4,5,6,7,0,1,2], target = 3 → Output: -1

Approach

This is a modified Binary Search problem.

Even though the array is rotated, at least one half of the array is always sorted.

Steps:

Initialize left and right pointers
Find the middle element
Check which half is sorted:
If left half is sorted:
Check if target lies in this range
Otherwise, right half must be sorted:
Check if target lies there
Narrow down the search accordingly

Repeat until the target is found or the search space is exhausted.

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

def search(nums, target):
    left, right = 0, len(nums) - 1

    while left <= right:
        mid = (left + right) // 2

        if nums[mid] == target:
            return mid
        if nums[left] <= nums[mid]:
            if nums[left] <= target < nums[mid]:
                right = mid - 1
            else:
                left = mid + 1
        else:
            if nums[mid] < target <= nums[right]:
                left = mid + 1
            else:
                right = mid - 1
    return -1
nums = [4,5,6,7,0,1,2]
target = 0
print(search(nums, target))

CA 19 - First & Last Occurences

Suruthika — Sun, 22 Mar 2026 18:14:01 +0000

Problem
First & Last Occurences
You are given a sorted array arr and a target value x.
Your task is to find the first and last occurrence of x.

If x is not present, return [-1, -1].

Input: [1, 3, 5, 5, 5, 5, 67, 123, 125], x = 5 → Output: [2, 5]
Input: [1, 3, 5, 5, 5, 5, 7, 123, 125], x = 7 → Output: [6, 6]
Input: [1, 2, 3], x = 4 → Output: [-1, -1]

Approach

Since the array is sorted, we can use Binary Search to efficiently find both positions.

Instead of stopping at the first match, we continue searching to find:

The leftmost occurrence (first position)
The rightmost occurrence (last position)
Steps:
Perform binary search to find the first occurrence:
Move left when a match is found
Perform binary search to find the last occurrence:
Move right when a match is found
If the element is not found, return [-1, -1]

This avoids scanning the entire array.

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

def findFirst(arr, x):
    left, right = 0, len(arr) - 1
    first = -1
    while left <= right:
        mid = (left + right) // 2
        if arr[mid] == x:
            first = mid
            right = mid - 1
        elif arr[mid] < x:
            left = mid + 1
        else:
            right = mid - 1
    return first
def findLast(arr, x):
    left, right = 0, len(arr) - 1
    last = -1
    while left <= right:
        mid = (left + right) // 2
        if arr[mid] == x:
            last = mid
            left = mid + 1
        elif arr[mid] < x:
            left = mid + 1
        else:
            right = mid - 1
    return last
def firstAndLast(arr, x):
    return [findFirst(arr, x), findLast(arr, x)
arr = [1, 3, 5, 5, 5, 5, 67, 123, 125]
x = 5
print(firstAndLast(arr, x))