DEV Community: Sharmila devi

Reverse a Linked List

Sharmila devi — Sun, 29 Mar 2026 06:22:39 +0000

Problem Statement
Given the head of a singly linked list, reverse the list and return the new head.

Example
Input
1 -> 2 -> 3 -> 4 -> 5
Output
5 -> 4 -> 3 -> 2 -> 1

Approach 1 Iterative Method
Reverse the links of the list one by one.

Steps
1 Initialize three pointers previous as None, current as head, next as None
2 Traverse the list
3 Store next node
4 Reverse current node link
5 Move previous and current one step forward
6 Repeat until current becomes None

Code
python id="ll1"
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 prev

Approach 2 Recursive Method

Reverse the list using recursion.

Code

python id="ll2"
def reverseList(head):
    if not head or not head.next:
        return head

    new_head = reverseList(head.next)

    head.next.next = head
    head.next = None

    return new_head

Explanation:
In the iterative method, we reverse the direction of pointers step by step.
In the recursive method, we reverse the rest of the list and then fix the current node.

Expected Output
Input
1 -> 2 -> 3 -> 4 -> 5
Output
5 -> 4 -> 3 -> 2 -> 1

Conclusion
Reversing a linked list is a fundamental problem that helps in understanding pointers and data structures. It is frequently asked in coding interviews.
Practice both iterative and recursive methods to strengthen your understanding.

Reverse the array

Sharmila devi — Sun, 29 Mar 2026 06:17:21 +0000

Problem
Reverse an array arr[]. Reversing means the first element becomes last, the second becomes second-last, and so on.

Example 1:
Input: arr = [1, 4, 3, 2, 6, 5]
Output: [5, 6, 2, 3, 4, 1]

Example 2:
Input: arr = [4, 5, 1, 2]
Output: [2, 1, 5, 4]

Approaches
Using Two Pointers (O(n) time, O(1) space)
Swap elements from start and end until you reach the middle.

def reverse_array(arr):
left, right = 0, len(arr) - 1
while left < right:
arr[left], arr[right] = arr[right], arr[left]
left += 1
right -= 1

arr = [1, 4, 3, 2, 6, 5]
reverse_array(arr)
print(arr)

Output:
[5, 6, 2, 3, 4, 1]

Swapping Elements by Index (O(n) time, O(1) space)
Iterate through the first half and swap with corresponding elements from the end.

def reverse_array(arr):
n = len(arr)
for i in range(n // 2):
arr[i], arr[n - i - 1] = arr[n - i - 1], arr[i]

arr = [1, 4, 3, 2, 6, 5]
reverse_array(arr)
print(arr)

Output:
[5, 6, 2, 3, 4, 1]

Using Inbuilt Method (O(n) time, O(1) space) def reverse_array(arr):

arr.reverse()
arr = [1, 4, 3, 2, 6, 5]
reverse_array(arr)
print(arr)

Output:
[5, 6, 2, 3, 4, 1]

Alter Tables

Sharmila devi — Sun, 29 Mar 2026 06:10:57 +0000

Make email NOT NULL in customers
ALTER TABLE customers
ALTER COLUMN email SET NOT NULL;
Make username UNIQUE in users
ALTER TABLE users
ADD CONSTRAINT unique_username UNIQUE (username);
Add CHECK (price > 0) in products
ALTER TABLE products
ADD CONSTRAINT price_check CHECK (price > 0);
Set default 'pending' in orders
ALTER TABLE orders
ALTER COLUMN status SET DEFAULT 'pending';
Add salary column in employees
ALTER TABLE employees
ADD COLUMN salary INT NOT NULL CHECK (salary > 10000);
Modify foreign key with ON DELETE CASCADE
First drop old constraint (name may vary)
ALTER TABLE employees
DROP CONSTRAINT employees_department_id_fkey;
Then add new one
ALTER TABLE employees
ADD CONSTRAINT fk_department
FOREIGN KEY (department_id)
REFERENCES departments(id)
ON DELETE CASCADE;
Remove CHECK constraint from accounts
First find constraint name, then:
ALTER TABLE accounts
DROP CONSTRAINT accounts_balance_check;
Add UNIQUE (user_id, transaction_id) in payments
ALTER TABLE payments
ADD CONSTRAINT unique_payment UNIQUE (user_id, transaction_id);

Create Tables

Sharmila devi — Sun, 29 Mar 2026 06:06:26 +0000

Students table (id unique)
CREATE TABLE students (
id SERIAL PRIMARY KEY,
name TEXT,
age INT
);
Employees table (name & email not null)
CREATE TABLE employees (
id SERIAL PRIMARY KEY,
name TEXT NOT NULL,
email TEXT NOT NULL,
phone_number TEXT
);
Users table (username & email unique)
CREATE TABLE users (
id SERIAL PRIMARY KEY,
username TEXT UNIQUE,
email TEXT UNIQUE
);
Products table (price > 0, stock ≥ 0)
CREATE TABLE products (
id SERIAL PRIMARY KEY,
name TEXT,
price DECIMAL CHECK (price > 0),
stock INT CHECK (stock >= 0)
);
Orders table (default + timestamp)
CREATE TABLE orders (
id SERIAL PRIMARY KEY,
status TEXT DEFAULT 'pending',
created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);
Accounts table
CREATE TABLE accounts (
id SERIAL PRIMARY KEY,
account_number TEXT UNIQUE NOT NULL,
balance INT CHECK (balance >= 0)
);
Enrollments table (unique combination)
CREATE TABLE enrollments (
student_id INT,
course_id INT,
PRIMARY KEY (student_id, course_id)
);
Departments & Employees (foreign key)
CREATE TABLE departments (
id SERIAL PRIMARY KEY,
name TEXT
);

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

Foreign key with cascade CREATE TABLE departments ( id SERIAL PRIMARY KEY, name TEXT );

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

Idempotency Situation

Sharmila devi — Sun, 29 Mar 2026 06:04:10 +0000

When I build a wallet system, I realized one common issue — same request can happen multiple times. This usually happens because of network retry or user clicking twice.

This is where Idempotency becomes important.
My Situation
Let’s say:
Alice → ₹1000
Bob → ₹500
I send ₹200 from Alice to Bob.

First Transfer
UPDATE accounts SET balance = balance - 200 WHERE name = 'Alice';
UPDATE accounts SET balance = balance + 200 WHERE name = 'Bob';

Now:
Alice → ₹800
Bob → ₹700
Same Request Happens Again

Due to retry, the same query runs again:
UPDATE accounts SET balance = balance - 200 WHERE name = 'Alice';
UPDATE accounts SET balance = balance + 200 WHERE name = 'Bob';

Now:
Alice → ₹600
Bob → ₹900

Money transferred twice
What I Observed
Database allows the same operation again
No automatic prevention
Duplicate transaction happens
Problem

Same request = executed multiple times
Balance becomes incorrect

How Real Systems Solve This
In real systems, I use an Idempotency Key.
Example:
txn_001
Before processing, I check:
“Is this transaction already done?”

Simple Logic
IF transaction_id exists
DO NOTHING
ELSE
PROCESS transaction
Final Result
First request → success
Duplicate request → ignored

No double deduction
Balance stays correct

Simple Idea
Same request should not change result again

Conclusion
Without idempotency:
Duplicate transactions happen
Money gets deducted multiple times

With idempotency:
Only one transaction is processed
System stays safe

So I remember it like this:
Even if request repeats, result should happen only once.

Durability

Sharmila devi — Sun, 29 Mar 2026 05:59:58 +0000

When I build a wallet system, I want to make sure that once money is transferred, it should never be lost. This is called Durability.

What Durability Means
Once I COMMIT a transaction, it is permanently saved
Even if the system crashes, data will still be there
Example Transfer
BEGIN;
UPDATE accounts SET balance = balance - 200 WHERE name = 'Alice';
UPDATE accounts SET balance = balance + 200 WHERE name = 'Bob';
COMMIT;

After this:
Alice → ₹800
Bob → ₹700
After Crash / Restart

Even if the database restarts, when I check again:
SELECT * FROM accounts;
I still see the updated balance.
Data is safe

Simple Idea
If COMMIT happens → data is saved forever
If not → changes are not saved

Conclusion
Durability ensures:

No data loss
Data stays permanent

So I remember it like this:
Once committed, it will never be lost.

Consistency

Sharmila devi — Sun, 29 Mar 2026 05:56:36 +0000

When I build a wallet system like PhonePe or GPay, I make sure the data is always correct. This is called Consistency in ACID.

What Consistency Means
Consistency means:
Data should always follow rules
No invalid data should be stored

My Table
CREATE TABLE accounts (
id SERIAL PRIMARY KEY,
name TEXT NOT NULL,
balance INT NOT NULL CHECK (balance >= 0),
last_updated TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

Here, I added:
CHECK (balance >= 0) → balance should never be negative

Dummy Data:
INSERT INTO accounts (name, balance)
VALUES
('Alice', 1000),
('Bob', 500);
Testing the Rules
Try to make balance negative
UPDATE accounts
SET balance = -100
WHERE name = 'Alice';

This will fail
Reason: database rule (CHECK constraint)

Try to deduct more money
UPDATE accounts
SET balance = balance - 2000
WHERE name = 'Alice';

This will also fail
Because balance becomes negative

What I Understand
Database itself blocks wrong data
It keeps balance valid
This is Consistency
Simple Idea

Database ensures rules
Data always stays correct

Conclusion
Consistency makes sure:

No negative balance
No wrong updates

So I remember it like this:
Data should always be valid before and after any operation.

Atomicity - Design a Reliable Wallet Transfer System with ACID Guarantees

Sharmila devi — Sun, 29 Mar 2026 05:49:28 +0000

Atomicity – Reliable Wallet Transfer with ACID (Simple)

When I learned about ACID properties, the one I understood first was Atomicity. It is very simple — it means all or nothing.

I can explain this using a wallet transfer example.

What I am trying to do

Let’s say:

Wallet A has ₹1000
Wallet B has ₹500
I want to send ₹200

So internally, two things should happen:

₹200 should be deducted from Wallet A
₹200 should be added to Wallet B
The Problem

If only one step happens, it becomes a big issue.

Example:

Money is deducted from A
But not added to B

Now ₹200 is lost. This is not acceptable in real applications.

How I Solve This

To avoid this, I use a database transaction.

BEGIN;

UPDATE wallet SET balance = balance - 200 WHERE id = 'A';
UPDATE wallet SET balance = balance + 200 WHERE id = 'B';

COMMIT;

If everything works fine → COMMIT

If any error happens in between →

ROLLBACK;
This cancels all changes and keeps the data safe.

Why Atomicity is Important
No money loss
No partial updates
System stays correct
Simple Idea
Transfer is one single action, not two separate steps

Conclusion
When I design a wallet system, I always use Atomicity to make it reliable.
Because in payments, even a small mistake can cause big problems.
So I always remember:
Either everything happens or nothing happens.

32 - Filter Assignments

Sharmila devi — Sun, 29 Mar 2026 05:41:27 +0000

Movies where special_features is NULL
SELECT * FROM film
WHERE special_features IS NULL;
Movies where rental duration > 7 days
SELECT * FROM film
WHERE rental_duration > 7;
Movies with rental rate = 4.99 and replacement cost > 20
SELECT * FROM film
WHERE rental_rate = 4.99
AND replacement_cost > 20;
Movies with rental rate = 0.99 OR rating = 'PG-13'
SELECT * FROM film
WHERE rental_rate = 0.99
OR rating = 'PG-13';
First 5 movies sorted by title
SELECT * FROM film
ORDER BY title ASC
LIMIT 5;
Skip first 10, get next 3 highest replacement cost
SELECT * FROM film
ORDER BY replacement_cost DESC
LIMIT 3 OFFSET 10;
Movies with rating G, PG, PG-13
SELECT * FROM film
WHERE rating IN ('G', 'PG', 'PG-13');
Movies with rental rate between 2 and 4
SELECT * FROM film
WHERE rental_rate BETWEEN 2 AND 4;
Movies with title starting with 'The'
SELECT * FROM film
WHERE title LIKE 'The%';
First 10 movies with conditions
SELECT * FROM film
WHERE rental_rate IN (2.99, 4.99)
AND rating = 'R'
AND title LIKE '%Love%'
LIMIT 10;
Movies where title contains %
SELECT * FROM film
WHERE title LIKE '%\%%' ESCAPE '\';
Movies where title contains _
SELECT * FROM film
WHERE title LIKE '%_%' ESCAPE '\';
Titles start with A or B and end with s
SELECT * FROM film
WHERE (title LIKE 'A%' OR title LIKE 'B%')
AND title LIKE '%s';
Titles containing Man, Men, or Woman
SELECT * FROM film
WHERE title LIKE '%Man%'
OR title LIKE '%Men%'
OR title LIKE '%Woman%';
Titles containing digits
SELECT * FROM film
WHERE title ~ '[0-9]';
Titles containing backslash ()
SELECT * FROM film
WHERE title LIKE '%\%';
Titles containing Love or Hate
SELECT * FROM film
WHERE title LIKE '%Love%'
OR title LIKE '%Hate%';
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;

Setup a DNS hosted zone in Route53 in AWS.

Sharmila devi — Sun, 29 Mar 2026 05:32:12 +0000

When I tried to connect my domain name to my server, I used Route 53 in AWS. At first, I thought it would be difficult, but it was actually simple when I followed the steps.

First, I logged into the AWS console and opened Route 53. Then I clicked on Hosted Zones and selected Create Hosted Zone.

Next, I entered my domain name (like mywebsite.com) and selected Public Hosted Zone. Then I clicked create.

After creating it, I saw some default records like NS and SOA. I understood that the NS records are important because they tell where my domain is managed.

If my domain was bought from somewhere else (like GoDaddy), I went there and updated the Name Servers with the ones given in Route 53. This step connects my domain to AWS.
Then I created a new record. I clicked on Create Record and added an A record.

In that:
I gave a name (like www)
Selected type as A
Entered my EC2 public IP address

Then I saved it.

After some time, I opened my domain in the browser, and it started working.
So in simple words, I created a hosted zone, updated name servers, and connected my domain to my server.
This is how I set up a DNS hosted zone in Route 53 in a simple way.

Create a simple EC2 instance and run a webserver and access it from outside.

Sharmila devi — Sun, 29 Mar 2026 05:24:35 +0000

Creating a Simple EC2 Instance and Running a Web Server

Whenever I started learning AWS, one of the first things I tried was creating an EC2 instance and hosting a simple web server. At first, it felt confusing, but when I did it step by step, it became very easy. Let me explain how I did it in a simple way.

First, I logged into the AWS Management Console. After that, I searched for EC2 and opened the EC2 dashboard. From there, I clicked on Launch Instance to create a new virtual machine.

Next, I gave a name to my instance and selected an Amazon Linux AMI. Then I chose a small instance type like t2.micro because it is free tier eligible.

After that, I created a key pair. This is important because it helps me connect to the instance securely. I downloaded the key file and saved it safely.

Then, I configured the network settings. Here I made an important change — I allowed HTTP (port 80) traffic so that I can access my web server from outside. Without this step, the website will not open in the browser.

Once everything was set, I clicked on Launch Instance. Within a few seconds, my EC2 instance was up and running.

Now I wanted to install a web server. For that, I connected to my instance using SSH. After connecting, I ran some simple commands to install Apache:

sudo yum update -y
sudo yum install httpd -y

Then I started the web server:

sudo systemctl start httpd

To make sure it runs even after restart, I enabled it:

sudo systemctl enable httpd

After that, I created a simple HTML page:

echo "Hello from my EC2 server!" | sudo tee /var/www/html/index.html

Now everything was ready. Finally, I copied the Public IP address of my EC2 instance and pasted it into my browser.

When I pressed enter, I could see my web page showing the message. That moment made me really happy because my server was now accessible from anywhere.

So in simple terms, I created a server in the cloud, installed a web server, and accessed it using a public IP.

This is how I learned to launch an EC2 instance and host a basic web server in AWS.

Write a blog on how DNS resolver is happening.

Sharmila devi — Sun, 29 Mar 2026 05:20:29 +0000

How DNS Resolver Works (In My Words)

Whenever I type a website name like google.com in my browser, I used to think it directly opens the site. But actually, there is a small process happening behind the scenes called DNS resolving. Let me explain it in a simple way based on how I understand it.

First, when I enter the website name, my browser doesn’t know where that website is stored. Because computers don’t understand names like google.com, they only understand IP addresses.

So my browser starts by checking if it already knows the IP address. It looks into something called cache (stored memory). This can be:

Browser cache
System cache

If the IP address is already there, then the website opens quickly without doing anything else.

If the IP is not found, then the real DNS resolving process starts.

My request goes to something called a DNS resolver. Usually, this is provided by my internet service provider (ISP). The resolver’s job is to find the correct IP address for the website I asked.

Now the resolver doesn’t know the answer directly, so it asks other servers step by step:

First, it contacts the Root Server. This server doesn’t give the exact IP, but it tells where to find the next level.

Next, it goes to the Top-Level Domain (TLD) server. For example, if I typed .com, it goes to the .com server. This server again doesn’t give the full answer but points to the next server.

After that, the resolver contacts the Authoritative Name Server. This is the final place where the actual IP address of the website is stored. This server gives the correct IP address.

Now the resolver gets the IP and sends it back to my browser. Also, it stores this IP in cache for some time, so next time it will be faster.

Finally, my browser uses this IP address to connect to the server and load the website.

Even though this process involves multiple steps, it happens very fast, in just milliseconds. That’s why I feel like the website opens instantly.

This is how DNS resolving works whenever I search for any website on the internet.