Rain water trapping

Raja71 — Sat, 31 Jan 2026 07:22:36 +0000

To calculate how much rainwater can be trapped between bars, we use a two-pointer technique that runs in O(n) time and O(1) space.

Core Idea

Water trapped at any index depends on:
min(max height on left, max height on right) - current height
Instead of precomputing arrays, we walk inward from both ends, keeping track of:

leftMax → tallest bar seen from the left

rightMax → tallest bar seen from the right

const trapping = height => {
let left = 0, right = height.length - 1;
let leftMax = 0, rightMax = 0, water = 0;

while (left < right) {
    if (height[left] < height[right]) {
        leftMax = Math.max(leftMax, height[left]);
        water += leftMax - height[left];
        left++;
    } else {
        rightMax = Math.max(rightMax, height[right]);
        water += rightMax - height[right];
        right--;
    }
}

return water;
}

1️⃣ Initialize pointers

left starts at beginning
right starts at end
leftMax and rightMax track the tallest bars seen so far
water stores total trapped water

2️⃣ Why compare height[left] < height[right]?

We always move the smaller height side because:
The trapped water is limited by the shorter boundary
If left bar is smaller → water depends on leftMax
If right bar is smaller → water depends on rightMax
This guarantees correctness without checking both sides every time.

3️⃣ When moving left pointer
leftMax = Math.max(leftMax, height[left]);
water += leftMax - height[left];
left++;

Update highest wall seen from left
Add water trapped at current index
Move inward

4️⃣ When moving right pointer
rightMax = Math.max(rightMax, height[right]);
water += rightMax - height[right];
right--;

Difference Between Regular Functions and Arrow Functions

Raja71 — Tue, 27 Jan 2026 17:10:37 +0000

“What is the difference between regular functions and arrow functions?” is one of the most commonly asked JavaScript interview questions.

While both look similar, they behave very differently when it comes to this, arguments, constructors, and more. In this blog, we’ll understand these differences with easy examples and real-world scenarios.

Regular Functions

Syntax

Regular functions must use the function keyword.

const add = function (num1, num2) {
return num1 + num2;
};

arguments object

Regular functions automatically get a special object called arguments.

You can access all passed values even without parameters.

const add = function () {
console.log(arguments);
};

add(1, 2, 3, 4);

Output:

{0: 1, 1: 2, 2: 3, 3: 4}

No implicit return

Regular functions do NOT return values automatically.

You must explicitly use return.

const sum = function (a, b) {
a + b; // nothing returned
};

this keyword

In regular functions, this depends on how the function is called.

let learnLng = {
lang: "JavaScript",
learnLang: function () {
console.log("Will start learning", this.lang);
}
};

learnLng.learnLang();
// Will start learning JavaScript

Arrow Functions

Syntax (short & clean)

Arrow functions are more concise.

const multiply = (num1, num2) => num1 * num2;

No arguments object

Arrow functions do NOT have their own arguments.

const add = () => {
console.log(arguments);
};

add(1, 2, 3);

ReferenceError: arguments is not defined

If you need arguments in arrow functions, use rest parameters:

const add = (...args) => {
console.log(args);
};

Implicit return

If the function has only one statement, arrow functions return it automatically.

const square = x => x * x;

No return needed

this keyword (lexical)

Arrow functions do NOT have their own this.

Instead, they borrow this from where they are written, not from how they are called.

let learnLng = {
lang: "JavaScript",
learnLang1: () => {
console.log("Will start learning", this.lang);
},
learnLang2: function () {
console.log("Will start learning", this.lang);
}
};

learnLng.learnLang1(); // undefined
learnLng.learnLang2(); // JavaScript

Why does this happen?
learnLang1 (arrow function):

this comes from outer scope

NOT from learnLng

So this.lang is undefined

learnLang2 (regular function):

this points to the object calling it (learnLng)

TL;DR

Regular functions use the function keyword; arrow functions use =>
Regular functions have their own this; arrow functions inherit this
Regular functions support arguments; arrow functions do not
Arrow functions allow implicit return for single expressions
Arrow functions cannot be used as constructors
Use regular functions for object methods
Use arrow functions for callbacks and short functions

Forem: Raja71

Rain water trapping

Difference Between Regular Functions and Arrow Functions

TL;DR