DEV Community: Abhishek Gupta

Backend Testing — Complete Notes

Abhishek Gupta — Fri, 03 Apr 2026 19:57:52 +0000

📌 1. What is Backend Testing?

Definition:

Backend testing means checking whether your server-side logic works correctly in all situations.

Simple Understanding:

When a user sends request:

User → API → Backend → Database → Response

👉 You must ensure:

Correct response is returned
Errors are handled properly
Data is stored correctly

❗ 2. Why Backend Testing is Important

Without Testing:

Bugs go to production ❌
Users face crashes ❌
Data corruption ❌
Security issues ❌

With Testing:

Bugs caught early ✅
Safe deployment ✅
Confident coding ✅
Faster development ✅

Real Example:

Case: User signup API

Without testing:

Duplicate emails allowed ❌
Password not validated ❌

With testing:

Duplicate → rejected ✅
Invalid input → error ✅

🧠 3. What Should You Test?

You should test:

✅ Functional Behavior

API works correctly

✅ Validation

Wrong input handled

✅ Security

Unauthorized access blocked

✅ Database

Data saved correctly

✅ Errors

Server errors handled

🧩 4. Types of Backend Testing

🔹 1. Unit Testing

Definition:

Test single function in isolation

Example:

function add(a, b) {
  return a + b;
}

Test:

expect(add(2, 3)).toBe(5);

Features:

Fast ⚡
No DB
No API

🔹 2. Integration Testing (MOST IMPORTANT)

Definition:

Test multiple layers together

Route → Controller → Service → DB

Example:

POST /users

Test:

Data sent
Saved in DB
Response returned

🔹 3. End-to-End Testing (E2E)

Definition:

Test full user journey

Example:

Register → Login → Access profile

Features:

Real-world testing
Slower

🏗️ 5. Backend Testing Tools

🥇 Core Tools

Jest
Supertest
MongoDB Memory Server
dotenv

🧠 6. Role of Each Tool

🧪 Jest

Runs tests
Provides describe, it, expect
Handles assertions
Supports mocking

🌐 Supertest

Sends HTTP requests
Tests APIs like Postman

🗄️ MongoMemoryServer

Fake DB
Fast & isolated

⚙️ dotenv

Separate test environment

⚙️ 7. How Testing Works (Flow)

Jest starts test
 ↓
Supertest sends request
 ↓
Backend processes request
 ↓
DB stores data
 ↓
Response returned
 ↓
Jest verifies result

🧱 8. Basic Setup

Install:

npm install --save-dev jest supertest mongodb-memory-server dotenv

package.json

"scripts": {
  "test": "jest"
}

🧪 9. First Test Example

import request from 'supertest';
import app from '../app';

describe('GET /', () => {
  it('should return message', async () => {
    const res = await request(app).get('/');

    expect(res.statusCode).toBe(200);
    expect(res.body.message).toBe('API working');
  });
});

🔥 10. Real Backend Test Cases

✅ Success Case

expect(res.statusCode).toBe(200);

❌ Validation Error

expect(res.statusCode).toBe(400);

🔒 Unauthorized

expect(res.statusCode).toBe(401);

🔁 Duplicate Data

expect(res.body.message).toMatch(/already exists/i);

💥 Server Error

expect(res.statusCode).toBe(500);

🔐 11. Authentication Testing

let token;

beforeAll(async () => {
  const res = await request(app)
    .post('/login')
    .send({ email, password });

  token = res.body.token;
});

it('should access protected route', async () => {
  const res = await request(app)
    .get('/profile')
    .set('Authorization', `Bearer ${token}`);

  expect(res.statusCode).toBe(200);
});

🧠 12. Database Testing

Use:

MongoDB Memory Server

Why:

No real DB
Fast
Clean

🧪 13. Mocking

Why needed?

To avoid calling real services

Example:

jest.mock('../emailService', () => ({
  sendEmail: jest.fn(),
}));

⚡ 14. Best Practices

✅ Do:

Test real API behavior
Cover edge cases
Keep tests independent

❌ Don’t:

Use real DB
Start server
Ignore errors

🧠 15. Testing Pyramid

Unit → Most
Integration → Medium
E2E → Few

📊 16. Code Coverage

npm test -- --coverage

⚙️ 17. CI/CD Testing

Use:

GitHub Actions

🧠 18. Interview Questions

Q: Why Jest?

👉 Easy + powerful

Q: Why Supertest?

👉 API testing without server

Q: Unit vs Integration?

👉 Function vs full flow

🚀 19. Advanced Topics

TDD
Load testing
Security testing
Contract testing

🏁 20. Final Summary

Jest = test runner
Supertest = API tester
DB memory = safe DB

🧠 Final Thought

Testing is not about checking code
It is about preventing failure before users face it

🚀 Sorting Algorithms in JavaScript (Complete Guide with Examples)

Abhishek Gupta — Sun, 29 Mar 2026 05:26:15 +0000

Let’s sort this array using different algorithms 👇

```js id="arr01"
let nums = [40, 10, 50, 80];




---

## 🔹 1. Bubble Sort

Repeatedly swaps adjacent elements if they are in the wrong order.



```js id="bubble01"
let arr = [...nums];

for (let i = 0; i < arr.length - 1; i++) {
  for (let j = 0; j < arr.length - i - 1; j++) {
    if (arr[j] > arr[j + 1]) {
      let temp = arr[j];
      arr[j] = arr[j + 1];
      arr[j + 1] = temp;
    }
  }
}

console.log(arr);

✅ Simple but slow (O(n²))

🔹 2. Selection Sort

Finds the smallest element and places it at the correct position.

```js id="selection01"
let arr = [...nums];

for (let i = 0; i < arr.length - 1; i++) {
for (let j = i + 1; j < arr.length; j++) {
if (arr[j] < arr[i]) {
let temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
}

console.log(arr);




✅ Fewer swaps than bubble sort
⚠️ Still O(n²)

---

## 🔹 3. Insertion Sort

Builds the sorted array one element at a time.



```js id="insertion01"
let arr = [...nums];

for (let i = 1; i < arr.length; i++) {
  let key = arr[i];
  let j = i - 1;

  while (j >= 0 && arr[j] > key) {
    arr[j + 1] = arr[j];
    j--;
  }

  arr[j + 1] = key;
}

console.log(arr);

✅ Efficient for small or nearly sorted arrays
⏱️ O(n²) worst case

🔹 4. Merge Sort (Divide & Conquer)

Breaks the array into halves, sorts them, and merges back.

```js id="merge01"
function mergeSort(arr) {
if (arr.length <= 1) return arr;

let mid = Math.floor(arr.length / 2);
let left = mergeSort(arr.slice(0, mid));
let right = mergeSort(arr.slice(mid));

return merge(left, right);
}

function merge(left, right) {
let result = [];
let i = 0, j = 0;

while (i < left.length && j < right.length) {
if (left[i] < right[j]) {
result.push(left[i]);
i++;
} else {
result.push(right[j]);
j++;
}
}

return result.concat(left.slice(i)).concat(right.slice(j));
}

console.log(mergeSort(nums));




✅ Much faster for large datasets
⏱️ O(n log n)
📌 Uses extra space

---

## 🔹 5. Built-in Sort (JavaScript)



```js id="builtin01"
let arr = [...nums];
arr.sort((a, b) => a - b);

console.log(arr);

✅ Fast and optimized (recommended in real-world use)

🧠 Final Output

All methods will return:

```js id="out01"
[10, 40, 50, 80]




---

## 💡 Key Takeaways

* Bubble, Selection, Insertion → Easy but slower (O(n²))
* Merge Sort → Efficient (O(n log n)) for large arrays
* Built-in `.sort()` → Best for practical use
* Always understand the logic before memorizing code

How to Print Alternate Elements of an Array in JavaScript (DSA)

Abhishek Gupta — Fri, 20 Mar 2026 09:11:10 +0000

🧩 Problem: Alternate Elements of an Array

Given an array arr[], your task is to print every alternate element of the array starting from the first element.

In other words, print elements at index 0, 2, 4, ... and skip the rest.

📥 Input

An array of integers arr[]

📤 Output

Print the alternate elements of the array (starting from index 0)

🧪 Examples

Example 1:

Input: arr[] = [10, 20, 30, 40, 50]
Output: 10 30 50

Explanation:
Print the first element (10), skip the second (20), print the third (30), skip the fourth (40), and print the fifth (50).

Example 2:

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

⚠️ Constraints

1 ≤ arr.length ≤ 10^5
-10^9 ≤ arr[i] ≤ 10^9

Solution

Approach 1


function removeAlternate(arr) {
  let Pointer1 = 1;
  let Pointer2 = 0;

  while (Pointer2 < arr.length - 1) {
    Pointer2++;

    if (Pointer2 % 2 === 0) {
      arr[Pointer1] = arr[Pointer2];
      Pointer1++;
    }
  }

  arr.length = Pointer1;
  return arr;
}

Approach 2


function removeAlternate(arr) {
  let Alternate_Arr = []
  let index = 0

  for(let i = 0 ; i < arr.length ; i++){
    if(i % 2 == 0 ){
      Alternate_Arr[index] = arr[i]
      index++

    }
  }

 return Alternate_Arr;

}

Approach 3


function removeAlternate(arr) {
  let Alternate_Arr = []
  let index = 0

  for(let i = 0 ; i < arr.length ; i++){
    if(i % 2 == 0 ){
      Alternate_Arr.push(arr[i])

    }
  }

 return Alternate_Arr;

}

Repeated Substring Pattern in JavaScript — Brute Force Approach Explained

Abhishek Gupta — Sat, 14 Mar 2026 15:06:22 +0000

Problem Statement

Given a string s, determine whether it can be constructed by repeating a substring of itself.

Return true if the string can be formed by repeating a substring, otherwise return false.

Example

Input: "abab"
Output: true
Explanation: "ab" repeated 2 times

Input: "abcabcabc"
Output: true
Explanation: "abc" repeated 3 times

Input: "aba"
Output: false

Input: "aaaa"
Output: true
Explanation: "a" repeated 4 times

Understanding the Problem

We need to check if a smaller substring repeats multiple times to form the entire string.

Example:

"abcabcabc"

Possible repeating substring:

"abc"

If we repeat "abc" three times:

"abcabcabc"

This matches the original string, so the answer is true.

But consider:

"aba"

There is no substring that can repeat to form "aba", so the answer is false.

Brute Force Approach

The simplest way to solve this problem is to try every possible substring and check if repeating it forms the original string.

Important observation:

The repeating substring length must divide the length of the string.

Example:

String = "abab"
Length = 4

Possible substring lengths:

1
2

Now test them.

Substring "a":

"a".repeat(4) → "aaaa" ❌

Substring "ab":

"ab".repeat(2) → "abab" ✅

So "ab" is the repeating substring.

Algorithm

Get the length of the string.
Iterate through all possible substring lengths from 1 to length / 2.
If the string length is divisible by the substring length:

Extract the substring.
Repeat it enough times to match the original length.
Compare it with the original string.
1. If a match is found → return true.
2. Otherwise return false.

JavaScript Implementation

var repeatedSubstringPattern = function(s) {

    let len = s.length;

    for (let i = 1; i <= len / 2; i++) {

        if (len % i === 0) {

            let sub = s.slice(0, i);

            if (sub.repeat(len / i) === s) {
                return true;
            }

        }

    }

    return false;
};

Testing the Solution

console.log(repeatedSubstringPattern("abcabcabcabc")); 
// true

console.log(repeatedSubstringPattern("aba")); 
// false

console.log(repeatedSubstringPattern("abab")); 
// true

console.log(repeatedSubstringPattern("aaaa")); 
// true

Dry Run Example

Let’s test the string:

"ababab"

Length:

Possible substring lengths:

1, 2, 3

Check each one.

Substring "a":

"a".repeat(6) → "aaaaaa" ❌

Substring "ab":

"ab".repeat(3) → "ababab" ✅

So the function returns true.

Time Complexity

O(n²)

Because we test multiple substring lengths and perform string comparisons.

The Complete Guide to Working With AI While Coding (Hackathons, Cursor, VS Code, AI Agents)

Abhishek Gupta — Tue, 10 Mar 2026 12:37:23 +0000

AI has fundamentally changed how developers build software.

In hackathons, startups, and daily development, many developers now rely on tools like:

Cursor
VS Code + GitHub Copilot
ChatGPT / Claude
Aider
Continue
Antigravity agents

These tools can:

generate code
modify multiple files
refactor large parts of a project
debug errors
suggest architecture
write tests
even build full features

Because of this, small teams can now build large systems extremely fast.

But there is a hidden problem.

Many developers use AI without a system.

At first everything feels amazing.
AI generates code quickly and features appear fast.

But after some time, the project starts breaking.

You begin to notice things like:

messy code structure
features randomly breaking
AI modifying unrelated files
duplicate logic appearing
debugging becoming harder and harder

This happens because developers don’t manage AI collaboration properly.

The correct approach is simple:

Treat AI like a developer on your team.

If a new developer joins your project, you don’t just say:

“Build whatever you want.”

You give them:

documentation
architecture explanation
coding rules
feature plans
debugging notes

AI needs the same structure.

This guide explains how to build a proper system for working with AI while coding.

Why AI Sometimes Breaks Your Project

AI tools work with limited context.

Most coding assistants only see:

the file you opened
a few related files
your conversation with the AI

They do not automatically understand your entire project.

Imagine your project has:

controllers
services
repositories
event systems
socket communication

If AI doesn’t understand those rules, it may generate code that breaks your architecture.

For example:

business logic placed inside controllers
duplicated services
incorrect database queries
conflicting APIs

The result is architecture drift.

To prevent this, developers must provide structured context for AI.

The Solution: Build an AI Workspace

The best way to work with AI is to treat your project as having two systems:

1️⃣ Your application code
2️⃣ Your AI collaboration system

A clean structure might look like this:

project-root/

README.md
AI_RULES.md

docs/
plans/
ai-logs/
debug/
reviews/
ai-history/

src/
tests/
scripts/

This structure helps both:

human developers
AI coding tools

understand the project.

Step 1: Write a Clear README

Many AI tools read the README first to understand the project.

A good README should explain:

what the project does
the technology stack
the main modules

Example:

# CommDesk

CommDesk is a platform for managing developer communities,
events, and hackathons.

Stack

Frontend: React + Vite
Backend: Node.js + Express
Database: MongoDB
Desktop: Tauri

This gives AI immediate context about your system.

Step 2: Create AI Rules

Create a file called:

AI_RULES.md

This file tells AI how your codebase works.

Example:

AI Rules

1. Controllers only handle HTTP requests.
2. Business logic must stay inside services.
3. Database queries belong in repositories.
4. Follow the existing folder structure.
5. Do not duplicate existing logic.

This prevents AI from breaking your architecture.

Step 3: Create a Documentation Folder

Create a folder:

docs/

Example structure:

docs/
AI_CONTEXT.md
ARCHITECTURE.md
FILE_STRUCTURE.md
CODING_GUIDELINES.md
SYSTEM_FLOW.md

These documents provide project-level understanding.

AI_CONTEXT.md

Explain what the project does.

Project Overview

CommDesk is a platform for managing developer communities.

Core modules:
- Authentication
- Event Management
- Notification System

ARCHITECTURE.md

Explain the system design.

Client → API → Services → Database

Services:

Auth Service
Event Service
Notification Service

FILE_STRUCTURE.md

Explain how the codebase is organized.

src/

controllers/
services/
models/
routes/
utils/

This prevents AI from inventing new random structures.

Step 4: Plan Features Before Asking AI

Instead of telling AI:

“Build notifications.”

Create a plan first.

plans/

Example files:

IMPLEMENTATION_PLAN.md
FUTURE_FEATURES.md
ROADMAP.md

Example feature plan:

Feature: Notification System

Step 1 Create database schema
Step 2 Create service layer
Step 3 Create API endpoints
Step 4 Add socket events
Step 5 Create UI components

Now AI can build features step by step.

Step 5: Track AI Changes

Create a folder:

ai-logs/

Example files:

CHANGE_LOG.md
PROMPTS.md
AI_SESSIONS.md

Example log:

Date: 2026-03-10
AI Tool: Cursor

Task:
Create Notification Service

Files Created:
src/services/notificationService.js

Files Updated:
src/controllers/notificationController.js

Tracking AI changes makes debugging much easier later.

Step 6: Store AI Session History

Create:

ai-history/

Example:

ai-history/
2026/
 03/
  10/
   session-1.md
   session-2.md

Example session log:

Date: 2026-03-10
Time: 15:30

AI Tool: Cursor

Task:
Create notification service

Files created:
notificationService.js

Developer Notes:
Added validation manually.

This becomes a timeline of how the project evolved.

Step 7: Track Bugs and Fixes

Create a folder:

debug/

Example files:

ERRORS.md
FIXES.md
INCIDENTS.md

Example:

Error

Notification event not triggering

Cause:

Incorrect socket event name

Fix:

Changed event name
notifyUser → notification:new

This builds a knowledge base of problems and solutions.

Step 8: Review AI Code

AI-generated code should always be reviewed.

Create:

reviews/

Example:

AI_REVIEW.md
CODE_REVIEW.md

Example review:

File
notificationService.js

Issues
Missing validation
Missing error handling

This keeps your codebase clean and maintainable.

Example AI Development Workflow

A typical workflow might look like this:

Feature Idea
      ↓
Write Implementation Plan
      ↓
Ask AI to generate step 1
      ↓
Review generated code
      ↓
Log AI changes
      ↓
Test the feature
      ↓
Fix bugs with AI
      ↓
Update documentation

Example Bug Fix Workflow

Bug detected
      ↓
Record in debug/ERRORS.md
      ↓
Ask AI to investigate
      ↓
Apply fix
      ↓
Log the change
      ↓
Document the solution

Best Practices When Using AI

Always:

ask AI for small tasks
review generated code carefully
track AI-generated changes
maintain documentation

Avoid:

generating entire systems in one prompt
blindly trusting AI output
skipping architecture planning

The Most Important Skill in the AI Era

Many developers believe the key skill today is prompt engineering.

But the real skill is:

Context Engineering

Context engineering means:

organizing documentation
structuring your project clearly
giving AI the right information
guiding AI step by step
maintaining development history

Developers who master this can build faster, more reliable software with AI.

Final Thoughts

AI tools like:

Cursor
Copilot
VS Code AI extensions
Antigravity
AI coding agents

are transforming software development.

But AI works best when it is guided properly.

When developers provide:

clear documentation
structured plans
coding rules
review processes

AI becomes a powerful development partner instead of a source of chaos.

And learning how to collaborate with AI will likely become one of the most important skills for developers in the coming years.

🧠 Sorting Algorithms Practice (Level 0 Hero)

Abhishek Gupta — Sun, 08 Mar 2026 07:34:44 +0000

Part 1 — Beginner Level (Problems 0–10)

Sorting is one of the core foundations of Data Structures and Algorithms. Many interview questions become easier after sorting the data.

Problem 0 — Sort Three Numbers

Difficulty

Easy

Problem Statement

You are given three integers a, b, and c.

Your task is to return the numbers in ascending order.

The result should be returned as an array or list.

Input

Three integers.

a = 7
b = 2
c = 5

Output

[2,5,7]

Example 1

Input
a = 10
b = 3
c = 6

Output
[3,6,10]

Explanation

The numbers sorted in ascending order are:

3 < 6 < 10

Constraints

-10^6 ≤ a,b,c ≤ 10^6

Hint

You can solve this by:

comparing numbers manually
using a small sorting algorithm
using built-in sort function

Problem 1 — Sort an Integer Array

Difficulty

Easy

Problem Statement

Given an integer array nums, sort the array in ascending order and return it.

You may use any sorting algorithm such as:

Bubble Sort
Merge Sort
Quick Sort
Heap Sort

Input

nums = [5,2,3,1]

Output

[1,2,3,5]

Example 2

Input
nums = [5,1,1,2,0,0]

Output
[0,0,1,1,2,5]

Constraints

1 ≤ nums.length ≤ 50000
-50000 ≤ nums[i] ≤ 50000

Explanation

Sorting the numbers in ascending order means:

smallest → largest

Original:

5,2,3,1

Sorted:

1,2,3,5

Hint

Efficient algorithms:

Merge Sort  → O(n log n)
Quick Sort  → O(n log n)

Problem 2 — Sort Array in Descending Order

Difficulty

Easy

Problem Statement

Given an array of integers nums, sort the array in descending order.

Input

nums = [1,5,3,2]

Output

[5,3,2,1]

Example 2

Input
nums = [10,4,7,1]

Output
[10,7,4,1]

Explanation

Descending order means:

largest → smallest

Constraints

1 ≤ nums.length ≤ 10^5

Hint

You can:

sort normally
reverse the result

Problem 3 — Check if Array is Sorted

Difficulty

Easy

Problem Statement

Given an array nums, determine whether the array is sorted in non-decreasing order.

Return:

true  → if sorted
false → otherwise

Input

nums = [1,2,3,4,5]

Output

true

Example 2

Input
nums = [1,3,2]

Output
false

Explanation

The second example fails because:

3 > 2

So the array is not sorted.

Constraints

1 ≤ nums.length ≤ 10^5

Hint

Loop through the array and check:

nums[i] ≤ nums[i+1]

Problem 4 — Bubble Sort Implementation

Difficulty

Easy

Problem Statement

Implement the Bubble Sort algorithm to sort an array in ascending order.

Bubble Sort repeatedly swaps adjacent elements if they are in the wrong order.

Input

nums = [5,1,4,2]

Output

[1,2,4,5]

Example

Original array

5 1 4 2

Pass 1

1 5 4 2
1 4 5 2
1 4 2 5

Pass 2

1 4 2 5
1 2 4 5

Sorted array

1 2 4 5

Constraints

1 ≤ nums.length ≤ 1000

Time Complexity

O(n²)

Problem 5 — Selection Sort Implementation

Difficulty

Easy

Problem Statement

Implement Selection Sort to sort the array.

Selection Sort works by repeatedly selecting the minimum element from the unsorted part and placing it at the beginning.

Input

nums = [64,25,12,22,11]

Output

[11,12,22,25,64]

Explanation

Steps

11 25 12 22 64
11 12 25 22 64
11 12 22 25 64

Time Complexity

O(n²)

Problem 6 — Insertion Sort Implementation

Difficulty

Easy

Problem Statement

Sort the array using Insertion Sort.

Insertion sort builds the sorted array one element at a time.

Input

nums = [8,3,5,2]

Output

[2,3,5,8]

Explanation

Steps:

Time Complexity

Best Case  → O(n)
Worst Case → O(n²)

Problem 7 — Move Zeros to End

Difficulty

Easy

Problem Statement

Given an array nums, move all 0s to the end of the array while maintaining the relative order of non-zero elements.

Input

nums = [0,1,0,3,12]

Output

[1,3,12,0,0]

Explanation

Original

0 1 0 3 12

Move zeros

1 3 12 0 0

Constraints

1 ≤ nums.length ≤ 10^4

Problem 8 — Sort Even and Odd Numbers

Difficulty

Easy

Problem Statement

Rearrange the array so that:

All even numbers appear first
All odd numbers appear after them

The relative order does not matter.

Input

nums = [3,1,2,4]

Output

[2,4,3,1]

Explanation

Even numbers

2 4

Odd numbers

3 1

Combined

2 4 3 1

Problem 9 — Sort 0s and 1s

Difficulty

Easy

Problem Statement

Given a binary array containing only 0 and 1, sort the array.

Input

nums = [1,0,1,0,1]

Output

[0,0,1,1,1]

Hint

Count number of:

zeros
ones

Problem 10 — Sort Array by Absolute Value

Difficulty

Easy

Problem Statement

Sort the array based on the absolute value of numbers.

Input

nums = [-4,-1,0,3,10]

Output

[0,-1,3,-4,10]

Explanation

Absolute values:

0 → 0
-1 → 1
3 → 3
-4 → 4
10 → 10

Sorted by absolute value.

Part 2 — Intermediate Level (Problems 11–20)

These problems introduce real interview patterns where sorting is used with:

Two pointers
Hash maps
Custom comparators
Frequency counting
Merging sorted data

Problem 11 — Sort Colors (Dutch National Flag Problem)

Difficulty: Medium

Problem Statement

You are given an array nums containing n objects colored red, white, or blue, represented by the integers:

0 → red  
1 → white  
2 → blue

Sort the array in-place so that objects of the same color are adjacent in the order:

0 → 1 → 2

You must solve the problem without using the built-in sort function.

Input

nums = [2,0,2,1,1,0]

Output

[0,0,1,1,2,2]

Example 2

Input
nums = [2,0,1]

Output
[0,1,2]

Constraints

1 ≤ nums.length ≤ 300
nums[i] ∈ {0,1,2}

Explanation

The sorted order should be:

0s → first
1s → middle
2s → last

Hint

Use the Dutch National Flag Algorithm with three pointers:

low
mid
high

Time Complexity:

O(n)

Problem 12 — Merge Two Sorted Arrays

Difficulty: Easy

Problem Statement

You are given two sorted arrays nums1 and nums2.

Merge nums2 into nums1 as one sorted array.

Input

nums1 = [1,2,3]
nums2 = [2,5,6]

Output

[1,2,2,3,5,6]

Example 2

Input
nums1 = [1,3,5]
nums2 = [2,4,6]

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

Constraints

1 ≤ nums1.length, nums2.length ≤ 1000

Explanation

Because both arrays are already sorted, we can merge them similar to the Merge step in Merge Sort.

Hint

Use two pointers:

i → nums1
j → nums2

Compare elements and insert the smaller one.

Problem 13 — Intersection of Two Sorted Arrays

Difficulty: Easy

Problem Statement

Given two sorted arrays, return their intersection.

The intersection should contain common elements appearing in both arrays.

Input

nums1 = [1,2,2,3]
nums2 = [2,2]

Output

[2,2]

Example 2

Input
nums1 = [1,3,4,5]
nums2 = [2,3,5,7]

Output
[3,5]

Constraints

1 ≤ nums1.length, nums2.length ≤ 1000

Hint

Use two pointers to scan both arrays.

Problem 14 — Union of Two Sorted Arrays

Difficulty: Easy

Problem Statement

Given two sorted arrays, return the union of the arrays.

The union should contain all unique elements from both arrays.

Input

nums1 = [1,2,4]
nums2 = [2,3,5]

Output

[1,2,3,4,5]

Example 2

Input
nums1 = [1,1,2,3]
nums2 = [2,3,4]

Output
[1,2,3,4]

Hint

Use:

two pointers
set

Problem 15 — Sort Array by Frequency

Difficulty: Medium

Problem Statement

Given an integer array nums, sort the array based on the frequency of values.

Rules:

Numbers with lower frequency come first
If frequencies are equal, larger numbers appear first

Input

nums = [2,3,1,3,2]

Output

[1,3,3,2,2]

Explanation

Frequencies:

1 → 1 time
3 → 2 times
2 → 2 times

Because 3 and 2 appear the same number of times, the larger number comes first.

Hint

Steps:

Count frequencies using a hashmap
Sort using a custom comparator

Problem 16 — Relative Sort Array

Difficulty: Medium

Problem Statement

You are given two arrays:

arr1
arr2

Elements in arr2 are unique and appear in arr1.

Sort arr1 such that:

Elements in arr2 appear first
Their order matches arr2
Remaining elements appear in ascending order

Input

arr1 = [2,3,1,3,2,4,6,7,9,2,19]
arr2 = [2,1,4,3,9,6]

Output

[2,2,2,1,4,3,3,9,6,7,19]

Hint

Use:

HashMap + Sorting

Problem 17 — Sort Characters by Frequency

Difficulty: Medium

Problem Statement

Given a string s, sort it in descending order based on character frequency.

Input

s = "tree"

Output

"eert"

Explanation

Frequency:

e → 2
t → 1
r → 1

The result starts with the most frequent character.

Hint

Steps:

count frequency
sort by frequency
rebuild string

Problem 18 — Sort Matrix Diagonally

Difficulty: Medium

Problem Statement

Given a matrix mat, sort each diagonal in ascending order.

Input

mat =
[
[3,3,1],
[2,2,1],
[1,1,1]
]

Output

[
[1,1,1],
[1,2,2],
[1,2,3]
]

Explanation

Each diagonal must be sorted independently.

Hint

Use:

HashMap<diagonal, values>

Then sort each list.

Problem 19 — Sort Linked List

Difficulty: Medium

Problem Statement

Given the head of a linked list, sort it in ascending order.

Input

4 → 2 → 1 → 3

Output

1 → 2 → 3 → 4

Constraints

0 ≤ nodes ≤ 50,000

Hint

Best solution:

Merge Sort on Linked List

Time Complexity:

O(n log n)

Problem 20 — Sort People by Height

Difficulty: Easy

Problem Statement

You are given two arrays:

names
heights

Sort the people by heights in descending order and return the names.

Input

names = ["Mary","John","Emma"]
heights = [180,165,170]

Output

["Mary","Emma","John"]

Explanation

Sorted by height:

180 → Mary
170 → Emma
165 → John

Great — let’s continue the series.
Below is Part 3: Problems 21–30 in a LeetCode-style detailed format, moving toward advanced sorting patterns such as QuickSelect, inversion counting, and swap optimization.

Part 3 — Upper-Intermediate Level (Problems 21–30)

These problems combine sorting with algorithmic techniques like:

Greedy strategies
Divide and conquer
QuickSelect
Heap / priority queue
Mathematical observations

These appear frequently in coding interviews.

Problem 21 — Kth Largest Element in an Array

Difficulty: Medium

Problem Statement

Given an integer array nums and an integer k, return the kth largest element in the array.

Note:
The kth largest element is the element that would appear in position k if the array were sorted in descending order.

Input

nums = [3,2,1,5,6,4]
k = 2

Output

Example 2

Input
nums = [3,2,3,1,2,4,5,5,6]
k = 4

Output
4

Constraints

1 ≤ k ≤ nums.length ≤ 100000
-10^4 ≤ nums[i] ≤ 10^4

Explanation

Sorted descending:

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

2nd largest element = 5

Hint

Efficient solutions:

QuickSelect
Heap

Time Complexity:

Average → O(n)

Problem 22 — Kth Smallest Element in an Array

Difficulty: Medium

Problem Statement

Given an array nums and an integer k, return the kth smallest element.

Input

nums = [7,10,4,3,20,15]
k = 3

Output

Explanation

Sorted array:

[3,4,7,10,15,20]

3rd smallest = 7

Hint

Use:

QuickSelect
Min Heap
Sorting

Problem 23 — Minimum Swaps to Sort Array

Difficulty: Medium

Problem Statement

Given an array of distinct integers, determine the minimum number of swaps required to sort the array.

Input

nums = [4,3,2,1]

Output

Explanation

Initial:

4 3 2 1

Swap:

4 ↔ 1
3 ↔ 2

Sorted:

1 2 3 4

Total swaps = 2

Hint

Use cycle detection in permutation.

Time Complexity:

O(n log n)

Problem 24 — Count Inversions in Array

Difficulty: Medium

Problem Statement

An inversion occurs when:

i < j
nums[i] > nums[j]

Your task is to count the total number of inversions in the array.

Input

nums = [2,4,1,3,5]

Output

Explanation

Inversions:

(2,1)
(4,1)
(4,3)

Total = 3

Hint

Efficient solution:

Merge Sort modification

Time Complexity:

O(n log n)

Problem 25 — Pancake Sorting

Difficulty: Medium

Problem Statement

You are given an array arr.

In one operation you can flip the first k elements of the array.

Return a sequence of flips that sorts the array.

Input

arr = [3,2,4,1]

Output

[4,2,4,3]

Explanation

Flip operations reverse prefixes until array becomes sorted.

Hint

Idea:

Bring largest element to front
Then flip to its correct position

Problem 26 — Wiggle Sort

Difficulty: Medium

Problem Statement

Reorder the array such that:

nums[0] ≤ nums[1] ≥ nums[2] ≤ nums[3] ≥ nums[4]

Input

nums = [3,5,2,1,6,4]

Output

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

Explanation

Check the pattern:

3 ≤ 5 ≥ 1 ≤ 6 ≥ 2 ≤ 4

Hint

Sort first then rearrange or use single pass swapping.

Problem 27 — Wiggle Sort II

Difficulty: Medium/Hard

Problem Statement

Rearrange numbers so that:

nums[0] < nums[1] > nums[2] < nums[3] > nums[4]

Input

nums = [1,5,1,1,6,4]

Output

[1,6,1,5,1,4]

Hint

Steps:

Find median
Three-way partition
Rearrange

Problem 28 — Maximum Gap

Difficulty: Hard

Problem Statement

Given an integer array nums, find the maximum difference between two successive elements in the sorted form of the array.

You must solve it in linear time.

Input

nums = [3,6,9,1]

Output

Explanation

Sorted array:

[1,3,6,9]

Differences:

2,3,3

Maximum = 3

Hint

Use Bucket Sort / Pigeonhole Principle.

Problem 29 — Top K Frequent Elements

Difficulty: Medium

Problem Statement

Given an integer array nums and an integer k, return the k most frequent elements.

Input

nums = [1,1,1,2,2,3]
k = 2

Output

[1,2]

Explanation

Frequency:

1 → 3 times
2 → 2 times
3 → 1 time

Top 2 frequent elements:

1,2

Hint

Possible approaches:

Heap
Bucket Sort
QuickSelect

Problem 30 — Sort Nearly Sorted Array

Difficulty: Medium

Problem Statement

An array is k-sorted if every element is at most k positions away from its sorted position.

Sort the array efficiently.

Input

nums = [6,5,3,2,8,10,9]
k = 3

Output

[2,3,5,6,8,9,10]

Hint

Use a Min Heap of size k+1.

Time Complexity:

O(n log k)

Below is Part 4 of the Sorting DSA Series (LeetCode Style).
These problems move from advanced → interview level and involve Quick Sort ideas, custom sorting, and greedy sorting logic.

🧠 Sorting Problems (Hero Level) — Part 4

16. Maximum Gap

Difficulty: Hard
Concepts: Sorting, Bucket Sort, Pigeonhole Principle

Problem

Given an integer array nums, return the maximum difference between two successive elements in its sorted form.

If the array contains less than two elements, return 0.

You must solve it in linear time and space if possible.

Example 1

Input:
nums = [3,6,9,1]

Output:
3

Explanation

Sorted array:

[1,3,6,9]

Differences:

3-1 = 2
6-3 = 3
9-6 = 3

Maximum gap = 3

Example 2

Input:
nums = [10]

Output:
0

Explanation

Only one element → no gap exists.

Constraints

1 ≤ nums.length ≤ 10^5
0 ≤ nums[i] ≤ 10^9

Follow-up

Solve in O(n) time without directly sorting.

17. Largest Number

Difficulty: Medium
Concepts: Custom Sorting, Comparator

Problem

Given a list of non-negative integers, arrange them such that they form the largest possible number.

Return the result as a string.

Example 1

Input:
nums = [10,2]

Output:
"210"

Example 2

Input:
nums = [3,30,34,5,9]

Output:
"9534330"

Explanation

Numbers must be sorted based on which concatenation produces a larger number.

Compare:

34 + 3 = 343
3 + 34 = 334

Since 343 > 334, 34 should come before 3.

Constraints

1 ≤ nums.length ≤ 100
0 ≤ nums[i] ≤ 10^9

18. H-Index

Difficulty: Medium
Concepts: Sorting, Counting

Problem

Given an array citations, where citations[i] is the number of citations a researcher received for their i-th paper.

Return the researcher's h-index.

Definition

A scientist has h-index = h if:

h papers have at least h citations each

Example

Input:
citations = [3,0,6,1,5]

Output:
3

Explanation

Sorted:

[0,1,3,5,6]

There are 3 papers with at least 3 citations.

19. Sort Array by Increasing Frequency

Difficulty: Easy
Concepts: Sorting + HashMap

Problem

Given an array of integers nums, sort the array based on:

Increasing frequency
If frequency is same → sort by decreasing number

Example

Input:
nums = [1,1,2,2,2,3]

Output:
[3,1,1,2,2,2]

Explanation

Frequency:

1 → 2 times
2 → 3 times
3 → 1 time

Sorted by frequency:

3 → 1 time
1 → 2 times
2 → 3 times

20. Queue Reconstruction by Height

Difficulty: Hard
Concepts: Sorting + Greedy

Problem

You are given an array people where:

people[i] = [hi, ki]

Where:

hi = height of person
ki = number of people in front with height ≥ hi

Reconstruct the queue.

Example

Input:
people = [[7,0],[4,4],[7,1],[5,0],[6,1],[5,2]]

Output:
[[5,0],[7,0],[5,2],[6,1],[4,4],[7,1]]

Explanation

Sort people by:

1️⃣ Height descending
2️⃣ k-value ascending

Then insert them at position k.

21. Minimum Number of Arrows to Burst Balloons

Difficulty: Medium
Concepts: Sorting + Greedy

Problem

You are given balloons represented by intervals:

[xstart, xend]

An arrow shot at position x bursts all balloons where:

xstart ≤ x ≤ xend

Return the minimum arrows needed.

Example

Input:
points = [[10,16],[2,8],[1,6],[7,12]]

Output:
2

Explanation

Burst:

Arrow 1 → [1,6] and [2,8]
Arrow 2 → [7,12] and [10,16]

22. Minimum Platforms (Train Problem)

Difficulty: Medium
Concepts: Sorting + Two Pointers

Problem

Given arrival and departure times of trains, find the minimum number of platforms required so that no train waits.

Example

Arrival:
[900, 940, 950, 1100, 1500, 1800]

Departure:
[910, 1200, 1120, 1130, 1900, 2000]

Output

Explanation

At 11:00 AM, three trains are present simultaneously.

23. Sort a Linked List

Difficulty: Medium
Concepts: Merge Sort on Linked List

Problem

Given the head of a linked list, sort the list in ascending order.

Time complexity should be:

O(n log n)

Example

Input:
head = [4,2,1,3]

Output:
[1,2,3,4]

24. Minimum Difference Between Largest and Smallest

Difficulty: Easy
Concepts: Sorting + Sliding Window

Problem

Given an integer array nums and integer k.

Choose k elements such that the difference between maximum and minimum is minimized.

Example

Input:
nums = [9,4,1,7]
k = 2

Output:
2

Explanation

Sorted:

[1,4,7,9]

Minimum difference:

4 - 1 = 3
7 - 4 = 3
9 - 7 = 2

Answer = 2

Find the Distance Value Between Two Arrays Easy Solution

Abhishek Gupta — Thu, 05 Mar 2026 09:10:54 +0000

The problem asks us to count how many elements in arr1 are far enough from every element in arr2.

For an element x in arr1, we must check that:

[
|x - y| > d
]

for every element y in arr2.

A simple way would be to compare every element of arr1 with every element of arr2, but that would take O(n × m) time.

To optimize this, we can sort arr2 and use Binary Search.
Binary search helps us quickly check if there exists an element in arr2 whose distance from arr1[i] is less than or equal to d.

If such an element exists, then the element from arr1 cannot be counted.

Approach

Sort arr2 so we can apply binary search.
For every element arr1[i]:

Use binary search on arr2.
During the search, check if

[
|arr2[mid] - arr1[i]| \le d
]

If such an element is found, return its index immediately.
If the search ends without finding such an element, return -1.
In the main function:

If binary search returns -1, it means no element in arr2 is within distance d.
Increase the count.

This reduces unnecessary comparisons and improves efficiency.

Complexity

Time complexity

Sorting arr2 → O(n log n)
Binary search for each element of arr1 → O(m log n)

Overall:

[
O(n \log n + m \log n)
]

Space complexity

No extra data structures are used apart from variables.

[
O(1)
]

Code

/**
 * @param {number[]} arr1
 * @param {number[]} arr2
 * @param {number} d
 * @return {number}
 */

// Binary search to check if an element in arr
// is within distance <= d from target
let BinarySearch = (arr, target, d) => {
  let Left = 0
  let Right = arr.length - 1

  while (Left <= Right) {
    let mid = Math.floor((Left + Right) / 2)

    // If distance is within d, target is too close
    if (Math.abs(arr[mid] - target) <= d) {
      return mid
    }

    // Standard binary search movement
    if (arr[mid] > target) {
      Right = mid - 1
    } else {
      Left = mid + 1
    }
  }

  // No element within distance d
  return -1
}

var findTheDistanceValue = function(arr1, arr2, d) {

  // Sort arr2 for binary search
  arr2.sort((a,b)=> a - b)

  let count = 0

  for(let i = 0 ; i < arr1.length ; i++){

    // Check if arr1[i] is close to any element in arr2
    let el = BinarySearch(arr2 , arr1[i] , d)

    // If no close element found, count it
    if(el === -1){
      count++
    }

  }

  return count
};

DSA Pattern Printing Question with js

Abhishek Gupta — Wed, 04 Mar 2026 13:44:49 +0000

Question 1

Write a program using nested loops to print a 4 × 4 grid of 1s.

Expected Output

Understanding the Problem

First, look at the output carefully.

We can notice two simple things:

There are 4 rows
Each row has 4 numbers

So the pattern is like a small square grid.

Row 1 → 1 1 1 1
Row 2 → 1 1 1 1
Row 3 → 1 1 1 1
Row 4 → 1 1 1 1

To print something like this, we use nested loops.

What are Nested Loops?

A nested loop means a loop inside another loop.

We use two loops because:

One loop handles rows
The other loop handles columns

Simple idea:

Outer loop → rows
Inner loop → numbers inside each row

Approach

Step 1 — Create the Row Loop

We need 4 rows, so we create a loop that runs 4 times.

for (let i = 0; i < 4; i++)

Every time this loop runs, it means a new row will be printed.

Step 2 — Create an Empty Row

Before printing numbers, we create an empty string.

let row = "";

This string will store the numbers for one row.

Step 3 — Create the Column Loop

Inside the first loop, we add another loop.

for (let j = 0; j < 4; j++)

This loop runs 4 times because each row needs 4 numbers.

Step 4 — Add the Number

Inside the second loop we add "1 " to the row.

row += "1 ";

After each loop run the row becomes:

First time  → 1
Second time → 1 1
Third time  → 1 1 1
Fourth time → 1 1 1 1

Step 5 — Print the Row

After the inner loop finishes, we print the row.

console.log(row);

Then the outer loop runs again to create the next row.

Final Code

for (let i = 0; i < 4; i++) {
  let row = "";

  for (let j = 0; j < 4; j++) {
    row += "1 ";
  }

  console.log(row);
}

Final Output

Question 2

Write a program using nested loops to print the following pattern.

Constraints:

Use two loops
The outer loop controls rows
The inner loop controls columns

Understanding the Pattern

The pattern has:

4 rows
3 columns

Row 1 → 333
Row 2 → 313
Row 3 → 323
Row 4 → 333

We notice that:

The top row and bottom row are completely 3.
The first column and last column are also 3.
Only the middle values change.

Edge Cases

1️⃣ Top Row

If the outer loop is at the first row, print 3 in all columns.

Condition

i === 0

Example

2️⃣ Bottom Row

If the outer loop reaches the last row, print 3 in all columns.

Condition

i === col - 1

Example

3️⃣ First Column

For middle rows, if the inner loop index is 0, print 3.

Condition

j === 0

Example

3 _ _

4️⃣ Last Column

If the inner loop reaches the last column, print 3.

Condition

j === row - 1

Example

_ _ 3

5️⃣ Middle Position

If the position is not on the edge, print the column number.

Row 2 → 313
Row 3 → 323

This happens using:

str += j + 1

Final Code

let row = 3
let col = 4

for (let i = 0; i < col; i++) {
  let str = "";

  for (let j = 0; j < row; j++) {

    if (i === 0 || i === col - 1) {
      str += row;
    } 
    else {
      if (j === 0 || j === row - 1) {
        str += row;
      } 
      else {
        str += j + 1;
      }
    }

  }

  console.log(str);
}

Output

Question 3

Write a program using nested loops to print the following number pattern.

Expected Output

Explanation

The first row prints 4 times the number 6.
The second row prints 3 times the number 5.
The third row prints 2 times the number 4.
The fourth row prints 1 time the number 3.

Approach

First, look at the pattern.

We can see two things:

The number changes in every row
The number of values in each row becomes smaller

Step 1 — Outer Loop (Rows)

The outer loop runs from 0 to 3, which means it runs 4 times.

Each time the outer loop runs, one row is printed.

Example:

i = 0 → first row
i = 1 → second row
i = 2 → third row
i = 3 → fourth row

So the outer loop decides how many rows we print.

Step 2 — Inner Loop (Columns)

At the beginning, the inner loop runs from 0 to 3.

That means the number will be printed 4 times.

Example:

Step 3 — After the First Row

When the first row is finished:

The number decreases
The number of columns also decreases

So now the inner loop runs from 0 to 2.

Output becomes:

Step 4 — Continue the Same Process

Every time a row is printed:

The number becomes smaller
The inner loop runs fewer times

Example:

Row 1 → inner loop runs 4 times → 6666
Row 2 → inner loop runs 3 times → 555
Row 3 → inner loop runs 2 times → 44
Row 4 → inner loop runs 1 time  → 3

Step 5 — How We Control This

After printing each row we update two things:

num--   → decrease the number
row--   → decrease how many times the inner loop runs

Because of this, both the number and the column size keep decreasing.

Final Code

let col = 4
let row = col
let num = (col - 1) * 2

for (let i = 0; i < col; i++) {

  let str = "";

  for (let j = 0; j < row; j++) {
    str += `${num}`
  }

  num--
  row--

  console.log(str);
}

🎓 Science Teacher Chatbot

Abhishek Gupta — Sat, 21 Feb 2026 00:08:07 +0000

🌱 0️⃣ What We Are Building

We are building an AI Science Teacher backend.

This AI:

answers science questions
explains like teacher
remembers conversation
ignores non-science

Example:

You: What is gravity?
AI: Gravity is a force…

You: explain simpler
AI: Imagine dropping a ball…

👉 AI remembered context.

🧠 1️⃣ How Chatbot Works (Easy)

Student → API → AI → Answer
           ↑
        Memory

Steps:

Student sends question
Backend receives
Memory added
AI generates answer
Answer returned

🧰 2️⃣ Tools We Use (Simple)

Node.js → runs backend
Express → API server
OpenAI → AI brain
LangChain → connects AI + memory
Memory → remembers chat
dotenv → loads API key

📦 3️⃣ Create Project

Open terminal:

mkdir science-teacher-bot
cd science-teacher-bot
pnpm init

📦 4️⃣ Install Packages

pnpm add express cors dotenv langchain @langchain/openai @langchain/core
pnpm add -D nodemon

📁 5️⃣ Project Structure

science-teacher-bot/
│
├── src/
│   ├── memory.mjs
│   ├── llm.mjs
│   ├── route.mjs
│   └── server.mjs
│
├── .env
└── package.json

🔐 6️⃣ Add OpenAI Key

Create .env

OPENAI_API_KEY=your_key_here
PORT=3000

💾 7️⃣ memory.mjs — Chat History Storage

This file stores conversation history for each user/session.

import { InMemoryChatMessageHistory } from "@langchain/core/chat_history";

const histories = {};

export function getSessionHistory(sessionId = "default") {
  if (!histories[sessionId]) {
    histories[sessionId] = new InMemoryChatMessageHistory();
  }
  return histories[sessionId];
}

🧠 What This Code Does

Creates memory storage for chatbot
Stores chat separately per user
Each user has unique sessionId
Returns that user’s history

👉 Enables multi-user chatbot memory.

Hinglish:
Har user ka alag chat history store hota hai

👤 What are `student1`, `student2` ?

They are session IDs (user IDs).

Example:

student1 → first user
student2 → second user

You pass them when calling chatbot.

So each user gets separate memory.

📦 What `new InMemoryChatMessageHistory()` Creates

It creates an object like:

InMemoryChatMessageHistory {
  messages: []
}

This object stores:

human messages
AI messages
conversation order

🔁 How histories Object Works

histories is a dictionary:

sessionId → chat history object

So:

histories["student1"] = InMemoryChatMessageHistory
histories["student2"] = InMemoryChatMessageHistory

🧪 Example Conversation

User: student1

Question:

What is gravity?

AI:

Gravity is a force that pulls objects.

Memory stored for student1.

User: student2

Question:

What is photosynthesis?

Memory stored separately.

📊 Example Output

After chats:

histories = {
  student1: InMemoryChatMessageHistory {
    messages: [
      { role: "human", content: "What is gravity?" },
      { role: "ai", content: "Gravity is a force that pulls objects." }
    ]
  },

  student2: InMemoryChatMessageHistory {
    messages: [
      { role: "human", content: "What is photosynthesis?" }
    ]
  }
}

🧾 Simplified View

Sometimes shown as:

histories = {
  student1: [
    { role: "human", content: "What is gravity?" },
    { role: "ai", content: "Gravity is a force that pulls objects." }
  ],
  student2: [
    { role: "human", content: "What is photosynthesis?" }
  ]
}

(This is conceptual view, actual object is InMemoryChatMessageHistory)

🔁 How It Is Used by LangChain

When chatbot runs:

getSessionHistory("student1")

LangChain:

Finds student1 history
Loads messages
Sends to AI
Adds new messages

So AI remembers conversation per user.

⚠️ Important Notes

Memory stored in RAM
Lost on server restart
Good for demo/testing
Production uses DB/Redis

Perfect 👍 — you want the same section completed and polished like your previous memory section, with:

clear explanation
beginner-friendly
consistent format
ready for notes

Below is your **final clean “🧠

🧠 8️⃣ llm.mjs — AI Chatbot Logic

Creates AI teacher + memory chatbot.

import { config } from "dotenv";
config();

import { ChatOpenAI } from "@langchain/openai";
import { ChatPromptTemplate, MessagesPlaceholder } from "@langchain/core/prompts";
import { RunnableWithMessageHistory } from "@langchain/core/runnables";
import { StringOutputParser } from "@langchain/core/output_parsers";
import { getSessionHistory } from "./memory.mjs";

const llm = new ChatOpenAI({
  model: "gpt-4o-mini",
  temperature: 0.3,
});

const prompt = ChatPromptTemplate.fromMessages([
  ["system", "You are a Science Teacher. Answer only science questions. Explain simply."],
  new MessagesPlaceholder("chat_history"),
  ["human", "{input}"],
]);

const chain = prompt.pipe(llm).pipe(new StringOutputParser());

export const chatChain = new RunnableWithMessageHistory({
  runnable: chain,
  getMessageHistory: getSessionHistory,
  inputMessagesKey: "input",
  historyMessagesKey: "chat_history",
});

🧠 What This File Does

Creates AI model
Defines teacher behavior
Connects chat memory
Creates chatbot system

👉 Main chatbot brain.

Hinglish:
Ye file AI teacher + memory chatbot banati hai

🤖 ChatOpenAI

Creates AI model.

Connects to OpenAI
Generates answers
Brain of chatbot

Hinglish:
AI model banata hai

🧾 Prompt (Teacher Rules)


const prompt = ChatPromptTemplate.fromMessages([
  ["system", "You are a Science Teacher. Answer only science questions. Explain simply."],
  new MessagesPlaceholder("chat_history"),
  ["human", "{input}"],
]);

Defines how AI behaves:

science teacher role
simple explanation
science-only answers

Hinglish:
AI ko teacher banata hai

🧠 MessagesPlaceholder("chat_history")

Inserts previous conversation
Loads user memory
Gives context to AI

Hinglish:
Yaha pichli chat aati hai

🔗 chain = prompt → AI → text

const chain = prompt.pipe(llm).pipe(new StringOutputParser());

Flow:

Prompt prepared
Sent to AI
Text answer returned

Hinglish:
Prompt → AI → answer

💾 RunnableWithMessageHistory

Adds memory to chatbot.

new RunnableWithMessageHistory({...})

Loads user chat history
Adds new messages
Maintains conversation

Hinglish:
AI ko user ki chat history deta hai

🏷️ inputMessagesKey: "input"

Name of user message field
Matches {input} in prompt

Hinglish:
Student ke question ka naam

🏷️ historyMessagesKey: "chat_history"

Name of memory variable
Matches MessagesPlaceholder

Hinglish:
Memory ka naam

🔁 How It Works (Example)

User: student1
Question: What is gravity?

LangChain sends to AI:

System: You are science teacher
History: (student1 chat)
User: What is gravity?

AI replies → stored in memory.

Next question uses same history.

🌐 9️⃣ route.mjs

API endpoint /ask

import { Router } from "express";
import { chatChain } from "./llm.mjs";

export const router = Router();

router.post("/", async (req, res) => {
  try {
    const { text, sessionId = "default" } = req.body;

    if (!text) {
      return res.status(400).json({ error: "Question required" });
    }

    const answer = await chatChain.invoke(
      { input: text },
      { configurable: { sessionId } }
    );

    res.json({ answer });

  } catch (err) {
    res.status(500).json({ error: "AI error" });
  }
});

Easy Meaning

Receives question
Sends to AI
Returns answer

🚀 1️⃣0️⃣ server.mjs

Starts backend server.

import express from "express";
import cors from "cors";
import { config } from "dotenv";
import { router } from "./route.mjs";

config();

const app = express();

app.use(cors());
app.use(express.json());

app.get("/", (req, res) => {
  res.send("Science Teacher AI running");
});

app.use("/ask", router);

const PORT = process.env.PORT || 3000;

app.listen(PORT, () => {
  console.log("Server running on http://localhost:" + PORT);
});

Easy Meaning

Creates server
Enables JSON
Adds API route
Starts app

▶️ 1️⃣1️⃣ Run Project

Add script in package.json:

"scripts": {
  "dev": "nodemon src/server.mjs"
}

Run:

pnpm dev

🧪 1️⃣2️⃣ Test Chatbot

POST → http://localhost:3000/ask

Body:

{
  "text": "What is gravity?"
}

Response:

{
  "answer": "Gravity is a force..."
}

🧠 1️⃣3️⃣ Memory Test

Send:

{ "text": "What is gravity?", "sessionId": "u1" }

Then:

{ "text": "Explain simpler", "sessionId": "u1" }

AI remembers 👍

🏆 1️⃣4️⃣ What You Built

You created:

AI backend
LangChain chatbot
Memory system
Express API
Science teacher AI

This is real AI architecture.

From Building Projects to Engineering Products

Abhishek Gupta — Tue, 17 Feb 2026 04:59:28 +0000

When I started building projects, I made a lot of mistakes.

I only focused on one thing:

“Make the project work somehow.”

I didn’t think about:

performance
scalability
clean architecture
optimization
maintainable code

If the feature worked, I was happy.

But everything changed when I began sharing my projects publicly and collaborating with other developers.

That’s when I realized:

Building a project and engineering a product are very different things.

🚀 The Beginner Mindset: Start Coding Immediately

Most beginner developers (including my past self) follow this pattern:

They get an idea like:

Let’s build an e-commerce app
Let’s build a WhatsApp clone
Let’s build a social media app

And they start coding immediately.

No research.

No planning.

No architecture.

No clarity about users.

At first, progress feels fast.

But after some time, confusion starts:

Should I use MongoDB or PostgreSQL?
Should I use Next.js or React?
How should my database schema look?
How will I store user data?
Can this handle many users?
How will authentication scale?
Should I use caching?

Now development slows down.

Because decisions were not made earlier.

❗ The Real Problem: Unclear Goal

Many developers take 6–7 months to build something that others finish in 2–3 months.

The reason is not skill.

The reason is unclear direction.

When the final goal is not clear:

you rewrite features
you change structure
you refactor repeatedly
you fix many bugs
you change tools mid-project

Time is lost not in coding —

but in deciding.

🧠 The Professional Mindset: Think Before You Build

Experienced developers don’t start coding immediately.

They first spend time understanding the product.

Sometimes:

1 week
15 days
1 month
even 2 months

Only planning and designing.

They define clearly:

What problem are we solving?
Who are the users?
What features are required?
How many users should it support?
What should the architecture look like?
How will data be stored?
Which tech stack fits best?
What are the trade-offs?

Then they start coding.

Because decisions are already made.

🔍 Treat Projects Like DSA Problems

There is a strong similarity between DSA and system design.

In DSA, we don’t start coding immediately.

We:

understand constraints
choose algorithm
compare approaches
dry-run solution

Good engineers do the same with software systems.

They design first.

Then implement.

🧱 My Biggest Early Mistake: Messy Codebase

In my early projects and open-source contributions, I didn’t care about structure.

I created:

random folders
unclear file names
long functions
duplicated logic
inconsistent patterns

Everything still worked — so I ignored it.

But as the project grew:

contributors struggled to understand code
features became harder to add
bugs increased
refactoring became risky
even I struggled to understand my own code 😅

The codebase became scary.

This is called code quality debt.

📈 When Projects Grow, Structure Matters

At the beginning, you are alone.

But if your project becomes useful:

other developers want to contribute
new features are added
modules increase
complexity grows

If the foundation is weak:

The project becomes hard to scale.

Good structure from the beginning saves months later.

🔄 The Key Shift: Project → Product

The biggest mindset change in my journey was this:

❌ I am building a project

✅ I am engineering a product

A project is for learning.

A product is for users.

When you think like product engineering, you start asking:

Is this readable?
Is this maintainable?
Is this scalable?
Can others understand this easily?
Is architecture future-ready?

That changes your coding style completely.

📝 What I Do Before Starting Any Project Now

Now I never start coding immediately.

I first create a simple plan document.

It includes:

1. Problem Definition

What problem does this solve?

2. Target Users

Who will use this?

3. Core Features

What is necessary (not everything)?

4. Architecture Idea

Frontend + Backend + DB flow

5. Database Schema Draft

Entities and relationships

6. Tech Stack Decision

Why this stack?

7. Scaling Assumption

Expected number of users

8. Folder Structure Plan

Project organization

9. Implementation Phases

Step-by-step build plan

After this, coding becomes smooth and fast.

📚 Why Documentation Makes You a Better Engineer

One habit that improved my thinking a lot:

I started documenting my projects.

For each project, I write:

what it does
why I built it
challenges faced
solutions used
architecture decisions
trade-offs
lessons learned

This helps in two ways:

Improves clarity of thinking
Shows depth to other developers

People don’t judge quickly — they understand your engineering process.

🧩 DSA and Development Are Similar Journeys

DSA is not about solving 1000 problems.

It’s about learning how to think.

Similarly, building apps is not about making many projects fast.

It’s about becoming a strong engineer.

💡 Advice to Beginners (From My Experience)

If you are starting development:

Don’t rush into coding
Think before building
Design simple architecture
Keep code clean from day one
Plan folder structure
Define schema early
Document decisions
Treat projects like products

You will save months of time later.

✅ Final Thought

Making messy projects is normal at the beginning.

I also did the same.

But growth starts when you realize:

Good developers write code.

Great engineers design systems.

And the moment you start treating your projects like products —

your engineering level changes.

Sliding Window Technique — Complete Guide (DSA)

Abhishek Gupta — Mon, 16 Feb 2026 07:23:45 +0000

1️⃣ What is Sliding Window?

Sliding Window is an algorithmic technique used to efficiently process a contiguous subarray / substring of fixed or variable size within an array or string.

Instead of recomputing values for every subarray from scratch, we reuse previous computation while moving the window forward.

👉 Think of it as a window of size k that slides over data.

Array: [1, 3, -1, -3, 5, 3, 6, 7]
k = 3

Window positions:
[1,3,-1]
  [3,-1,-3]
    [-1,-3,5]
      [-3,5,3]
         [5,3,6]
           [3,6,7]

2️⃣ What does “Window” mean?

A window = group of elements currently being processed together.

If k = 3, at any iteration you analyze exactly 3 elements.

So:

Window size = how many elements you analyze at once

3️⃣ How Sliding Window Works

Instead of:

For every subarray of size k:
    calculate result from scratch

We do:

Compute first window result
Then slide:
    Remove left element
    Add right element
    Update result efficiently

This reduces repeated work.

4️⃣ Example — Maximum in Subarray (Your Example)

Array:

[1, 3, -1, -3, 5, 3, 6, 7]
k = 3

Windows:

[1,3,-1]  → max = 3
[3,-1,-3] → max = 3
[-1,-3,5] → max = 5
[-3,5,3]  → max = 5
[5,3,6]   → max = 6
[3,6,7]   → max = 7

Output:

[3,3,5,5,6,7]

5️⃣ Types of Sliding Window

✅ 1. Fixed Size Window

Window size constant (k given)

Examples:

Maximum sum subarray of size k
Average of subarray size k
Max/min in window size k

✅ 2. Variable Size Window

Window expands & shrinks dynamically

Examples:

Longest substring without repeating characters
Minimum window substring
Longest subarray with sum ≤ K

6️⃣ Naive vs Sliding Window

❌ Naive Approach

For each window → scan k elements

Time:

O(n * k)

✅ Sliding Window

Reuse previous result

Time:

O(n)

Huge improvement.

7️⃣ Sliding Window Algorithm Pattern (Fixed)

1. Process first window (0 → k-1)
2. For i = k → n-1
       remove element i-k
       add element i
       update answer

8️⃣ Code — Maximum Sum Subarray Size K

JavaScript

function maxSumSubarray(arr, k) {
  let windowSum = 0;
  let maxSum = -Infinity;

  // first window
  for (let i = 0; i < k; i++) {
    windowSum += arr[i];
  }
  maxSum = windowSum;

  // slide window
  for (let i = k; i < arr.length; i++) {
    windowSum += arr[i];      // add right
    windowSum -= arr[i - k];  // remove left
    maxSum = Math.max(maxSum, windowSum);
  }

  return maxSum;
}

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

9️⃣ Hard Version — Maximum Element in Window (Deque)

Your example problem requires monotonic deque.

Why?
Because max changes non-linearly.

Algorithm Idea

Deque stores indexes of useful elements
Maintains decreasing order.

Rules:

1. Remove out-of-window elements
2. Remove smaller elements from back
3. Add current index
4. Front = max

JavaScript Code

function maxSlidingWindow(nums, k) {
  const deque = [];
  const result = [];

  for (let i = 0; i < nums.length; i++) {

    // remove out of window
    if (deque.length && deque[0] <= i - k) {
      deque.shift();
    }

    // remove smaller elements
    while (deque.length && nums[deque[deque.length - 1]] < nums[i]) {
      deque.pop();
    }

    deque.push(i);

    // start recording after first window
    if (i >= k - 1) {
      result.push(nums[deque[0]]);
    }
  }

  return result;
}

Time: O(n)
Space: O(k)

🔟 Variable Sliding Window Pattern

Used when window size unknown.

Template

left = 0
for right in range:
    expand window

    while condition invalid:
        shrink window
        left++

    update answer

1️⃣1️⃣ Example — Longest Substring Without Repeat

function longestUnique(s) {
  const set = new Set();
  let left = 0;
  let maxLen = 0;

  for (let right = 0; right < s.length; right++) {

    while (set.has(s[right])) {
      set.delete(s[left]);
      left++;
    }

    set.add(s[right]);
    maxLen = Math.max(maxLen, right - left + 1);
  }

  return maxLen;
}

1️⃣2️⃣ Real-World Examples of Sliding Window

📊 1. Network Traffic Monitoring

Find peak bandwidth usage in last 5 minutes.

Window = last 5 min packets.

💰 2. Stock Market Analysis

Maximum price in last 30 days.

Window = 30 days.

🎥 3. Video Streaming Buffer

Analyze last N frames for compression.

🧠 4. NLP / Text Processing

Longest meaningful phrase without repetition.

📱 5. Sensor Data Processing

Average temperature last 10 readings.

🔒 6. Cybersecurity

Detect anomalies in last N requests.

1️⃣3️⃣ Time Complexity Analysis

Problem Type	Time	Space
Fixed sum/avg	O(n)	O(1)
Max/min (deque)	O(n)	O(k)
Variable window	O(n)	O(k)

Why O(n)?
Each element enters & exits window once.

1️⃣4️⃣ When to Use Sliding Window

Use when you see:

✅ Subarray
✅ Substring
✅ Contiguous segment
✅ Fixed length k
✅ Range processing
✅ Running average/sum/max
✅ Longest/shortest condition

1️⃣5️⃣ Sliding Window vs Two Pointers

Sliding window = specialized two-pointer.

Two pointers:

left, right move independently

Sliding window:

right expands
left shrinks conditionally

1️⃣6️⃣ Common Interview Problems

Must know:

Maximum sum subarray size k
Sliding window maximum
Longest substring without repeat
Minimum window substring
Longest subarray with sum ≤ K
Count subarrays with condition
Fruit into baskets
Anagrams in string

1️⃣7️⃣ Common Mistakes

❌ Forget removing left element
❌ Off-by-one window size
❌ Wrong while condition
❌ Not updating answer after shrink
❌ Using sliding window for non-contiguous problems

1️⃣8️⃣ Intuition (Most Important)

Brute force:

Recalculate everything

Sliding window:

Reuse previous work
Update only change

This is the core optimization mindset.

1️⃣9️⃣ Visual Intuition

[1,3,-1,-3,5,3,6,7]
 k=3

Step1: [1,3,-1]
Step2:   [3,-1,-3]
Step3:     [-1,-3,5]

Only:

remove left
add right

Everything else same.

🍫 Chocolate Distribution Problem — JavaScript Solution Explained (Sliding Window)

Abhishek Gupta — Mon, 16 Feb 2026 06:39:24 +0000

This is a very common coding interview problem that teaches how to distribute items fairly.

In this blog, we will understand the problem from zero level and then solve it step-by-step using JavaScript.

🧾 Problem in Simple Words

We have many chocolate packets.

Each packet has some chocolates.

Example:

arr = [7, 3, 2, 4, 9, 12, 56]

This means:

Packet 1 → 7 chocolates
Packet 2 → 3 chocolates
Packet 3 → 2 chocolates
Packet 4 → 4 chocolates
Packet 5 → 9 chocolates
Packet 6 → 12 chocolates
Packet 7 → 56 chocolates

We also have students:

m = number of students

Example:

m = 3

So we must give exactly 1 packet to each student.

🎯 Goal (Most Important Part)

We must choose m packets such that:

maximum chocolates − minimum chocolates

is as small as possible.

This is called minimized difference.

🤔 Why Difference?

Because we want fair distribution.

Bad distribution:

[2, 3, 56]
diff = 56 − 2 = 54 ❌ unfair

Good distribution:

[2, 3, 4]
diff = 4 − 2 = 2 ✅ fair

So we always prefer packets that are close in value.

🔑 Important Observation

If we sort the packets, similar values come together.

Example:

Original: [7, 3, 2, 4, 9, 12, 56]
Sorted:   [2, 3, 4, 7, 9, 12, 56]

Now close chocolate counts are neighbors.

So the best m packets will always be next to each other in sorted array.

This is the key idea of the problem.

🧠 Approach Step-by-Step

Step 1 → Sort the array
Step 2 → Take m consecutive packets
Step 3 → Find difference
Step 4 → Move window
Step 5 → Keep minimum

This is called sliding window.

📦 Example Walkthrough 1

arr = [7, 3, 2, 4, 9, 12, 56]
m = 3

Sort:

[2, 3, 4, 7, 9, 12, 56]

Now take groups of 3:

[2,3,4] → diff = 4−2 = 2
[3,4,7] → diff = 7−3 = 4
[4,7,9] → diff = 9−4 = 5
[7,9,12] → diff = 12−7 = 5
[9,12,56] → diff = 56−9 = 47

Minimum = 2

So answer = 2

📦 Example Walkthrough 2

arr = [1, 4, 7, 8, 9]
m = 3

Sort:

[1, 4, 7, 8, 9]

Now take groups of 3:

[1,4,7] → diff = 7−1 = 6
[4,7,8] → diff = 8−4 = 4
[7,8,9] → diff = 9−4 = 2

Minimum = 2

So answer = 2

💻 JavaScript Code (Easy)

function findMinDiff(arr, m) {
  // Step 1: sort chocolates
  arr.sort((a, b) => a - b);

  let minDiff = Number.MAX_SAFE_INTEGER;

  // window pointers
  let start = 0;
  let end = m - 1;

  // Step 2: slide window
  while (end < arr.length) {
    let diff = arr[end] - arr[start];

    if (diff < minDiff) {
      minDiff = diff;
    }

    start++;
    end++;
  }

  return minDiff;
}

▶️ Test

console.log(findMinDiff([7, 3, 2, 4, 9, 12, 56], 3));

Output:

🔍 Code Explanation Line-by-Line

Sort array

arr.sort((a, b) => a - b);

Now chocolates are in increasing order.

Store minimum difference

let minDiff = Number.MAX_SAFE_INTEGER;

Start with very large number.

Create window of size m

let start = 0;
let end = m - 1;

Example:

m = 3
start = 0
end = 2
window = [2,3,4]

Slide window

while (end < arr.length)

Move window one step each time.

Calculate difference

let diff = arr[end] - arr[start];

Because:

max = arr[end]
min = arr[start]

Update minimum

if (diff < minDiff) {
  minDiff = diff;
}

Keep best answer.

Move window

start++;
end++;

Next group.

⏱ Time Complexity

Sorting:

O(n log n)

Sliding window:

O(n)

Total:

O(n log n)

🧩 Why This Solution is Correct

After sorting:

closest numbers stay together
best packets must be neighbors
checking neighbors = checking all optimal choices

So sliding window finds best answer.

🏁 Final Understanding

We want to distribute chocolates fairly.

Fair means:

max − min → smallest

Sorting + sliding window checks all fair groups.

Minimum difference is the answer.

✅ Final Answer

Chocolate Distribution problem is solved by:

Sorting packets
Checking all groups of m packets
Choosing group with minimum difference