DEV Community: Padma Priya R

How DNS resolver is happening?

Padma Priya R — Fri, 27 Mar 2026 18:34:21 +0000

WHAT IS DNS ?
DNS means Domain Name System

*ROLE OF DNS *
it converts the website name into ip address

PROXY used in DNS
REVERSE PROXY - Mid man between the client and the servers it distributes the request.
FORWARD PROXY - Multiple requests are converted into single request.

what is DNS resolver ?
A DNS resolver is a server that helps you find the IP address of a website.

** FLOW OF DNS RESOLVER**

USER - DNS QUERY INTIALIZATION - SUB RESOLVER (local machine internet cache DHCP) - RESOLVER - ISP (internet server provider it acts as a gateway between device and internet)

EXAMPLE
www.wikipedia.org.
here (.) - indicates the Root of DNS system.(even without the root the website can run )
org - indicates the top level domain it will point the secondary level domain when we ask for the ip address
wikipedia - idicates the secondary level domain holds the ip address
www - indicates the subdomain even without sub domain also the website can run.

how it works?
step 1 - Receives request from machine
step 2 - Checks if it already knows the answer like if we already search for it our machine has a memory of our search (cache) If not it will ask the:
Root of DNS system
TLD server
SLD server
Get the IP address
Hitback to our machine

How a request originates from client and reaches the server ?

Padma Priya R — Fri, 27 Mar 2026 18:07:24 +0000

General Flow:
when the machine is connected in the same network, the machine send the request to the modem the modem searches wheather it able to read the request send by the other machine and the response got from the machine is send to modem the modem send back the response to the machine that arise the request.
MACHINE 1 > REQ > SWITCH AND ROUTER > MODEM > MACHINE 2 > RES > MODEM > MSG > MACHINE 1.

what is client and server ?
Client: Your machine that requests information.
Server: the system that stores and provides data based on our request basically it response for our request.

Example
searching on Google

we(user) ask the query Request goes to Google server the Server search the request results(response)come back to the user.

user - Browser- request - DNS - Google Server - response - Display - user

HOW INTERNET WORKS ? WHAT IS IP ADDRESS,SUBNET and DNS 🤔💭

Padma Priya R — Fri, 27 Mar 2026 17:48:58 +0000

WHAT IS INTERNET ?
Internet is a wide range of system that allows the machines to connect world wide to share and communicate with each other using the standard Protocols.

IP ADDRESS ?
AN IP address is a unique address for each and every device in Internet.
It is used to send messages and communicate to the devices when it is connected in the same network.

THE IP ADDRESS IS DIVIDED INTO TWO PARTS NAMELY

The Network Part
The Host Part
Example: 10.1.34.81/24
here the /24 defines the network
where 10.1.4 indicates the network part and remaining 81 denotes the host part.
The ip holds till 32 bits it cannot be extended. It can be allocated from (0 to 255)
The tool CIDR calculator is used to calculate The no of devices can be connected to the internet using the ip address.

TYPES OF IP ADDRESS
Public ip address - will be standard (eg: a college holds a public ip from that the subnets were divided but the public ip for the college unique and only that college has that ip in the world)
Private ip address - Can be used in the closed area Network.

FLOW OF HOW INTERNET WORKS ?
when the machine is connected in the same network, the machine send the request to the modem the modem searches wheather it able to read the request send by the other machine and the response got from the machine is send to modem the modem send back the response to the machine that arise the request.
MACHINE 1 > REQ > MODEM > MACHINE 2 > RES > MODEM > MSG > MACHINE 1

SUBNETS
The subnet is a smaller network inside the larger network
example : an public ip can have multiple subnets.

DNS
it converts the websites into ip address

EXAMPLE
www.wikipedia.org.
here (.) - indicates the Root of DNS system.(even without the root the website can run )
org - indicates the top level domain it will point the secondary level domain when we ask for the ip address
wikipedia - idicates the secondary level domain holds the ip address
www - indicates the subdomain even without sub domain also the website can run.

PROXY used in DNS
REVERSE PROXY - Mid man between the client and the servers it distributes the request.
FORWARD PROXY - Multiple requests are converted into single request.

Sorting Algorithms in Python

Padma Priya R — Sun, 22 Mar 2026 16:20:02 +0000

**Sorting helps to organize data efficiently and is frequently asked in coding interviews. In this post, we cover four commonly taught sorting algorithms: Bubble Sort, Selection Sort, Insertion Sort, and Merge Sort. Each is illustrated with a simple problem, Python implementation.

1. Bubble Sort
Problem
Given an integer array nums, sort it in ascending order using Bubble Sort.

class Solution:
def bubbleSort(self, nums):
n = len(nums)
for i in range(n):
for j in range(0, n-i-1):
if nums[j] > nums[j+1]:
nums[j], nums[j+1] = nums[j+1], nums[j]
return nums

Example
nums = [5, 2, 3, 1]
sol = Solution()
print("Sorted array:", sol.bubbleSort(nums))

2. Selection Sort
Problem
Given an array of integers, sort it in ascending order using Selection Sort.

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]

arr = [64, 25, 12, 22, 11]
selection_sort(arr)
print("Sorted array:", arr)

3. Insertion Sort
Problem
Given an array of numbers, sort them in ascending order using Insertion Sort.

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

arr = [12, 11, 13, 5, 6]
insertion_sort(arr)
print("Sorted array:", arr)

4. Merge Sort

Problem
Given an array of integers, sort it using the divide-and-conquer approach (Merge Sort).

def merge_sort(arr):
if len(arr) > 1:
mid = len(arr)//2
L = arr[:mid]
R = arr[mid:]

    merge_sort(L)
    merge_sort(R)

    i = j = k = 0
    while i < len(L) and j < len(R):
        if L[i] < R[j]:
            arr[k] = L[i]
            i += 1
        else:
            arr[k] = R[j]
            j += 1
        k += 1

    while i < len(L):
        arr[k] = L[i]
        i += 1
        k += 1

    while j < len(R):
        arr[k] = R[j]
        j += 1
        k += 1

arr = [38, 27, 43, 3, 9, 82, 10]
merge_sort(arr)
print("Sorted array:", arr)

Merge Two Sorted Linked Lists

Padma Priya R — Sun, 22 Mar 2026 14:06:47 +0000

Problem Statement

You are given the heads of two sorted linked lists, list1 and list2. Your task is to merge the two lists into one sorted linked list by splicing together the nodes of the first two lists.

Return the head of the merged linked list.

Examples

Example 1:

Input: list1 = [1,2,4], list2 = [1,3,4]
Output: [1,1,2,3,4,4]

Example 2:

Input: list1 = [], list2 = []
Output: []
Example 3:

Input: list1 = [], list2 = [0]
Output: [0]

Approach

Create a dummy node to serve as the start of the merged list.
Use a pointer current to track the last node in the merged list.
Compare the nodes from both lists:
Append the smaller node to current.next.
Move the pointer of the list from which the node was taken.
Once one list is exhausted, append the remaining nodes from the other list.
Return dummy.next as the head of the merged list

Python Code

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

class Solution:
def mergeTwoLists(self, list1: ListNode, list2: ListNode) -> ListNode:
dummy = ListNode(-1)
current = dummy

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

    # Append remaining nodes
    if list1:
        current.next = list1
    elif list2:
        current.next = list2

    return dummy.next

Merge Sort on a Linked List

Padma Priya R — Sun, 22 Mar 2026 08:44:06 +0000

Problem Statement

Given the head of a singly linked list, sort it using Merge Sort.

Examples:

Input:
10 -> 30 -> 20 -> 50 -> 40 -> 60

Output:
10 -> 20 -> 30 -> 40 -> 50 -> 60

Input:
9 -> 2 -> 5 -> 8

Output:
2 -> 5 -> 8 -> 9

Constraints:

Number of nodes: 1 ≤ n ≤ 10^5
Node values: 0 ≤ node->data ≤ 10^6
Expected time complexity: O(n log n)
Expected space complexity: O(log n) (due to recursion)
Approach

steps:

Base : If the list is empty or has only one node, it is already sorted.
Divide: Find the middle of the linked list using the slow and fast pointer technique and split it into two halves.
Conquer & Merge: Recursively sort both halves and merge them using a helper function that merges two sorted linked lists.

Python Code

class Solution:
# Function to merge two sorted linked lists
def merge(self, a, b):
if not a:
return b
if not b:
return a

    if a.data <= b.data:
        result = a
        result.next = self.merge(a.next, b)
    else:
        result = b
        result.next = self.merge(a, b.next)

    return result

# Function to find the middle of the linked list
def getMiddle(self, head):
    if not head:
        return head

    slow = head
    fast = head.next

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

    return slow

# Main function to sort linked list using merge sort
def mergeSort(self, head):
    # Base case: 0 or 1 node
    if not head or not head.next:
        return head

    # Step 1: Split the list into halves
    middle = self.getMiddle(head)
    next_to_middle = middle.next
    middle.next = None  # split the list

    # Step 2: Recursively sort the two halves
    left = self.mergeSort(head)
    right = self.mergeSort(next_to_middle)

    # Step 3: Merge the sorted halves
    sorted_list = self.merge(left, right)
    return sorted_list

Explanation

Finding the middle: The getMiddle() function uses slow and fast pointers. Slow moves one step, fast moves two steps. When fast reaches the end, slow points to the middle.
Merging lists: The merge() function merges two sorted linked lists recursively.
Recursive sorting: The mergeSort() function splits the list, sorts both halves, and merges them back together.

Remove Duplicates from a Sorted Linked List

Padma Priya R — Sun, 22 Mar 2026 08:37:27 +0000

Problem Statement

Given a singly linked list, remove all duplicate nodes so that only the first occurrence of each value remains.

Examples:

Input:
2 -> 2 -> 4 -> 5

Output:
2 -> 4 -> 5

Input:
2 -> 2 -> 2 -> 2 -> 2

Output:
2

Constraints:

Number of nodes: 1 ≤ n ≤ 10^5
Node values: 1 ≤ data ≤ 10^5
Expected time complexity: O(n)
Expected space complexity: O(1)

Approach
Start from the head node.
Compare the current node with the next node.
If they are equal, skip the next node by updating current.next.
Otherwise, move to the next node.
Repeat until the end of the list.

Python Code

def removeDuplicates(head):
current = head
while current and current.next:
if current.data == current.next.data:
current.next = current.next.next # skip duplicate
else:
current = current.next
return head

Explanation

We use a pointer current to traverse the linked list.
For each node, we check if its data is equal to the data of the next node.
If yes, we skip the next node by pointing current.next to current.next.next.
Otherwise, we move current forward.
This ensures all duplicates are removed in one pass.

Reverse a Linked List

Padma Priya R — Sun, 22 Mar 2026 08:28:11 +0000

Problem Statement

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 -> 5
Output: 5 -> 4 -> 3 -> 2 -> 1

Notes:

The linked list may have any number of nodes.
You can reverse it in-place or using extra space, depending on the approach.

Approach 1: Iterative Method

The iterative approach uses three pointers: prev, curr, and nextNode. At each step:

Store curr.next in nextNode.
Reverse the link: curr.next = prev.
Move the pointers forward: prev = curr, curr = nextNode.
Repeat until curr becomes None.
Return prev as the new head.

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

def reverseList(head):
prev, curr = None, head
while curr:
nextNode = curr.next
curr.next = prev
prev = curr
curr = nextNode
return prev

def printList(node):
while node:
print(node.data, end="")
if node.next:
print(" -> ", end="")
node = node.next
print()

head = Node(1)
head.next = Node(2)
head.next.next = Node(3)
head.next.next.next = Node(4)
head.next.next.next.next = Node(5)

head = reverseList(head)
printList(head)

Output:
5 -> 4 -> 3 -> 2 -> 1

Approach 2: Recursive Method

The recursive approach works by:

Recursively reaching the last node of the list.
Making each node point back to its previous node as the recursion returns.
Returning the new head of the reversed list.

code

def reverseList(head):
if head is None or head.next is None:
return head

rest = reverseList(head.next)
head.next.next = head
head.next = None
return rest

Approach 3: Using a Stack

The stack approach involves:

Traversing the linked list and pushing all nodes onto a stack.
Popping nodes from the stack and linking them in reverse order.
Returning the new head.
code

def reverseList(head):
stack = []
temp = head
while temp:
stack.append(temp)
temp = temp.next

head = stack.pop()
temp = head
while stack:
    temp.next = stack.pop()
    temp = temp.next
temp.next = None
return head

Comparison of Approaches

Iterative: O(n) time, O(1) space – most efficient.
Recursive: O(n) time, O(n) space – uses call stack.
Stack: O(n) time, O(n) space – easy to use.

Majority Element

Padma Priya R — Sun, 22 Mar 2026 08:21:38 +0000

Problem Statement

Given an array arr[], find the majority element in the array.

A majority element is an element that appears strictly more than arr.size()/2 times.
If no majority element exists, return -1.
Examples
Input: arr = [1, 1, 2, 1, 3, 5, 1]
Output: 1

Explanation: 1 appears more than 7/2 = 3.5 times.

Input: arr = [7]
Output: 7

Explanation: Single element is trivially the majority.

Input: arr = [2, 13]
Output: -1

Explanation: No element appears more than 2/2 = 1 times.

Constraints
1 ≤ arr.size() ≤ 10^5
1 ≤ arr[i] ≤ 10^5

Approach : Use Hash Map

Count the frequency of each element using a dictionary. If an element count exceeds n//2, return it.

from typing import List

class Solution:
def majorityElement(self, arr: List[int]) -> int:
n = len(arr)
freq = {}

    for num in arr:
        freq[num] = freq.get(num, 0) + 1
        if freq[num] > n // 2:
            return num

    return -1

Search in Rotated Sorted Array

Padma Priya R — Sun, 22 Mar 2026 08:12:36 +0000

Problem Statement

You are given an integer array nums sorted in ascending order (with distinct values), which may be rotated at an unknown pivot index k (1 <= k < nums.length).

Example of rotation: [0,1,2,4,5,6,7] rotated by 3 - [4,5,6,7,0,1,2].
Given a target value, return the index of the target in nums, or -1 if it’s not present.

You must achieve O(log n) runtime complexity.

Examples
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
Input: nums = [1], target = 0
Output: -1

Constraints:

1 <= nums.length <= 5000
-10^4 <= nums[i] <= 10^4
All values of nums are unique
nums is ascending but possibly rotated
-10^4 <= target <= 10^4

Approach: Modify the Binary Search

Since the array is rotated but sorted, a modified binary search works efficiently:

Start with low = 0 and high = len(nums) - 1.
While low <= high:
Calculate mid = low + (high - low) // 2.
If nums[mid] == target, return mid.
Determine which side is sorted:
If nums[low] <= nums[mid], the left side is sorted.
If target lies within [nums[low], nums[mid]], search left (high = mid - 1), else search right.
Else, the right side is sorted.
If target lies within [nums[mid], nums[high]], search right (low = mid + 1), else search left.

Python code

from typing import List

class Solution:
def search(self, nums: List[int], target: int) -> int:
low, high = 0, len(nums) - 1

    while low <= high:
        mid = low + (high - low) // 2

        if nums[mid] == target:
            return mid

        # Left half is sorted
        if nums[low] <= nums[mid]:
            if nums[low] <= target < nums[mid]:
                high = mid - 1
            else:
                low = mid + 1
        # Right half is sorted
        else:
            if nums[mid] < target <= nums[high]:
                low = mid + 1
            else:
                high = mid - 1

    return -1

Working:

Each iteration eliminates half of the search space by checking which half is sorted.
Then we determine if the target lies in the sorted half.
If yes, we search that half; otherwise, we search the other half.

First and Last Occurrences

Padma Priya R — Sun, 22 Mar 2026 08:02:25 +0000

Problem Statement

Given a sorted array arr (which may contain duplicates), find the first and last occurrences of an element x.

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

Examples:

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

Constraints:

1 ≤ arr.size() ≤ 10^6
1 ≤ arr[i], x ≤ 10^9

Approach: Binary Search

Since the array is sorted, binary search allows us to efficiently find the first and last occurrences of x.

Steps:

First Occurrence:
Perform binary search.
If arr[mid] == x, move the high pointer to mid - 1 to check if x occurs earlier.
Last Occurrence:
Perform binary search.
If arr[mid] == x, move the low pointer to mid + 1 to check if x occurs later.

This ensures O(log n) time complexity for each search, perfect for large arrays.

Python CODE

from typing import List

class Solution:
def find(self, arr: List[int], x: int) - List[int]:
n = len(arr)

    # Find first occurrence
    first, last = -1, -1
    low, high = 0, n - 1

    while low <= high:
        mid = low + (high - low) // 2
        if arr[mid] < x:
            low = mid + 1
        elif arr[mid] > x:
            high = mid - 1
        else:
            first = mid
            high = mid - 1  # Move left to find first occurrence

    # If element not found
    if first == -1:
        return [-1, -1]

    # Find last occurrence
    low, high = first, n - 1
    while low <= high:
        mid = low + (high - low) // 2
        if arr[mid] > x:
            high = mid - 1
        else:
            last = mid
            low = mid + 1  # Move right to find last occurrence

    return [first, last]

How It Works:

Binary search allows skipping unnecessary elements.
First occurrence moves left when arr[mid] == x.
Last occurrence moves right when arr[mid] == x.
Handles no occurrence by returning [-1, -1].

Squares of a Sorted Array

Padma Priya R — Sun, 22 Mar 2026 07:57:04 +0000

Problem Statement

Given an integer array nums sorted in non-decreasing order, return an array of the squares of each number, also sorted in non-decreasing order.

Example 1:

Input: nums = [-4, -1, 0, 3, 10]
Output: [0, 1, 9, 16, 100]

Explanation:
After squaring, the array becomes [16, 1, 0, 9, 100].
After sorting, it becomes [0, 1, 9, 16, 100].

Example 2:

Input: nums = [-7, -3, 2, 3, 11]
Output: [4, 9, 9, 49, 121]

Constraints:

1 <= nums.length <= 10^4
-10^4 <= nums[i] <= 10^4
nums is sorted in non-decreasing order

Approach: Two-Pointers

Since the array is sorted, negative numbers squared can be larger than positive numbers squared.
A two-pointer approach allows us to place squares in the correct order without sorting:

Initialize two pointers: left = 0 and right = len(nums) - 1.
Compare abs(nums[left]) and abs(nums[right]).
Place the larger square at the end of the result array.
Move the corresponding pointer inward.
Repeat until all elements are processed.

This approach avoids the extra sorting step, giving O(n) complexity.

Python Code

from typing import List

class Solution:
def sortedSquares(self, nums: List[int]) - List[int]:
n = len(nums)
result = [0] * n
left, right = 0, n - 1
pos = n - 1

    while left <= right:
        if abs(nums[left]) > abs(nums[right]):
            result[pos] = nums[left] ** 2
            left += 1
        else:
            result[pos] = nums[right] ** 2
            right -= 1
        pos -= 1

    return result

Working:

The largest square is always at one of the ends.
Fill the result array from right to left to maintain sorted order.
Move the pointers inward until all elements are squared and placed correctly.