DEV Community: Laxman Nemane

🔗 Linked List Explained Simply (Singly vs Doubly)

Laxman Nemane — Sat, 14 Mar 2026 08:15:09 +0000

📚 Today I learned the Linked List concept in DSA

I just read Linked List and now I'll teach it. Linked List is one of the most beautiful concepts where most data manipulation happens, like insertion and deletion. For these operations, Linked List is the best use case.

🔹 We'll learn what a Linked List is. Basically, there are two types of Linked Lists:
1️⃣ Singly Linked List
2️⃣ Doubly Linked List

➡️ Singly Linked List means each node links to the next node. A node contains a value and a reference to the next node. This flow continues by connecting to the next node reference, which is why it is called singly.

↔️ The same thing happens in Doubly Linked List, but in this case the node has two pointers:
• Next
• Previous position reference

📌 An additional thing: the first node in a Linked List is technically called the head, and the last node is called the tail. The tail points to null.

✅ This is what I learned today.

🧠 We also have an exercise for tech leaders and coders. If you know or you are learning, then solve this puzzle:

addelementatindex(2,8) in 3,1,4,5
➡️ 3,1,8,4,5

🫧 Bubble Sort Explained Simply

Laxman Nemane — Fri, 27 Feb 2026 04:52:51 +0000

Let’s break it down in the simplest way possible.

🚀 What is Bubble Sort?

Bubble Sort is a simple comparison-based sorting algorithm.
It works by:

Repeatedly stepping through the list
Comparing adjacent elements
Swapping them if they are in the wrong order
Repeating until the array is sorted

The largest elements "bubble up" to the end — hence the name Bubble Sort 🫧

Understanding Linear Search & Binary Search 🔍

Laxman Nemane — Wed, 25 Feb 2026 18:45:37 +0000

Today I learned about Linear Search and Binary Search.

First, let’s talk about Linear Search.
It is an algorithm used to search for an element in an array.

If we go deeper, Linear Search checks elements one by one from start to end until:
The element is found, or The list ends.

Let’s take a real-life example:

If I am searching for the name "Lakhan" and it is present at index 4, then the 0th, 1st, 2nd, and 3rd iterations will fail. At the 4th iteration, it will find the element, return it, and stop the loop.

That’s how Linear Search works.

Now, let’s talk about Binary Search.

On the internet, it says Binary Search is the fastest and most optimized way to search for an element. Basically, it is an optimized way to search an element in a sorted array.

It does not work on an unsorted array.

If we go deeper, Binary Search divides the array into halves each time. It checks the middle element and continues the search only in the relevant half, while ignoring the other half.

This process continues until the element is found or the search space becomes empty.

🚀 Day of Strengthening My DSA Fundamentals – JavaScript String Methods

Laxman Nemane — Tue, 24 Feb 2026 18:35:01 +0000

Today I learned the remaining string methods in JavaScript.

Yesterday, I posted on Dev Community about the string methods I had already learned.
Here is the URL of that post:
https://dev.to/laxmann/day-of-strengthening-my-dsa-fundamentals-javascript-string-methods-44b9

In that post, I covered the earlier methods.
Now I’m sharing the methods I learned today.

Let’s start by revising the string methods:

🔹 slice()
Extracts a section of a string and returns a new string without modifying the original one.

It takes two parameters:
startIndex endIndex

The string between these two indexes is returned.

The startIndex is included.
The endIndex is excluded.

🔹 split()
Converts a string into an array.
It takes two parameters:
separator limit

The separator defines where to split the string.
The limit defines how many items you want in the resulting array.

🔹 substring()
Works similarly to slice().

It takes:
startIndex endIndex

And returns the part of the string between those indexes.

🔹 trim()
Removes whitespace from both ends of the string.

🔹 trimEnd()
Removes whitespace from the end of the string.

🔹 trimStart()
Removes whitespace from the beginning of the string.

🔹 startsWith()
Checks whether a string starts with a given character or substring.

Returns:
true
false

🔹 toLocaleUpperCase()
Converts a string to uppercase using locale-specific case mapping.

It can take a locale as a parameter.

🔹 toUpperCase()
Converts a string to uppercase using default Unicode rules (not locale-specific).

🔹 toLowerCase() / toLocaleLowerCase()
Same concept as uppercase methods, but converts the string to lowercase.

✅ What I Learned Today
Today I strengthened my understanding of:

How string methods return new values
The difference between slice() and substring()
How split() works internally

The difference between locale-based and default Unicode case conversion

If you see any mistakes or have suggestions, please let me know.
I continually improve my DSA fundamentals.

🚀 Day of Strengthening My DSA Fundamentals – JavaScript String Methods

Laxman Nemane — Mon, 23 Feb 2026 18:27:05 +0000

Today, I focused on building strong fundamentals by learning and revising basic string operations in JavaScript.

Mastering string manipulation is extremely important for coding interviews, especially for product-based companies and FAANG-level roles.

Here’s what I learned today 👇

📌 1️⃣ Basic Properties
✅ length
Returns the total number of characters in a string (including spaces).

"Hello".length // 5

📌 2️⃣ Accessing Characters
✅ at(index)

Returns the character at a given index.
Supports negative indexing.


"Hello".at(1)  // "e"
"Hello".at(-1) // "o"

✅ charAt(index)

Returns the character at a given index.
❌ Does NOT support negative indexing.

"Hello".charAt(1) // "e"

📌 3️⃣ Searching in Strings
✅ includes(searchString, position)

Returns true or false.


"banana".includes("a")     // true
"banana".includes("b", 1)  // false

✅ indexOf(searchString, position)

Returns the first occurrence index or -1.

"banana".indexOf("a") // 1

✅ lastIndexOf(searchString)

Returns the last occurrence index.

"banana".lastIndexOf("a") // 5

📌 4️⃣ Modifying Strings
✅ concat()

Combines strings and returns a new string.

"Hello".concat(" ", "World")

✅ replace(pattern, replacement)

Replaces only the first occurrence.


"banana".replace("a", "x")
// "bxnana"

✅ replaceAll(pattern, replacement)

Replaces all occurrences.

"banana".replaceAll("a", "x")
// "bxnxnx"

📌 5️⃣ Padding Methods
✅ padStart(targetLength, padString)

Adds characters at the beginning.


"7".padStart(3, "0")
// "007"

✅ padEnd(targetLength, padString)

Adds characters at the end.


"34".padEnd(5, "*")
// "34***"

📌 6️⃣ Pattern Matching
✅ match()

Returns matched results (array) or null.
Often used with regular expressions.


"banana".match(/a/g)
// ["a", "a", "a"]

💡 Key Learnings

Strings are immutable in JavaScript.
Most string methods return a new string.
Searching methods are case-sensitive.
Understanding return types is very important for interviews.

Consistency > Motivation 🚀

DSA #JavaScript #LearningInPublic #FrontendDeveloper #FAANGJourney

🚀 Today I Learned the Most Amazing DSA Concept — Recursion!

Laxman Nemane — Mon, 04 Aug 2025 05:18:33 +0000

Hey friends,
Today was mind-blowing 🤯 because I learned something in DSA that feels like magic — Recursion.

It’s actually very simple… but at first, you might not fully get it. That’s okay! Keep practicing and one day, it will just click.

🔍 What is Recursion?
Recursion is when a function calls itself using its own definition.

There are two most important parts of recursion:

Base Case → This stops the recursion (very important 🚨).
Recursive Call → Where the function calls itself again.

🧠 A Real-Life Example
Imagine a queue of 6 people: A, B, C, D, E, F.

A doesn’t know how many people are behind him, so he asks B.

B doesn’t know either, so he asks C.

This continues until F.

F says, “Nobody is behind me!” (Base Case).

Then the answer comes back step-by-step to A.

That’s how recursion flows — going deep until a base case, then returning back.

💡 Fun Fact
If you type recursion in Google, it will say:
Did you mean: recursion?
Click it… and it will suggest recursion again. Infinite loop! 😂 Google is trolling us but also teaching recursion in a fun way.

🖥 Simple Programming Example
javascript


function fn(n) {
    console.log("Lakhan");
    n = n - 1;
    fn(n); // Recursive Call
}

fn(5);

⚠️ This will keep going forever and crash with Stack Overflow because there’s no base case.

✅ Correct Way with Base Case
javascript


function fn(n) {
    if (n === 0) return; // Base Case - stops recursion
    console.log("Lakhan");
    fn(n - 1); // Recursive Call
}

fn(5);

Now it prints "Lakhan" 5 times and stops.

🏗 How It Works in Call Stack
fn(5) calls fn(4) (fn(5) is paused until fn(4) finishes)

fn(4) calls fn(3)

… and so on, until fn(0) hits the base case.

Then functions start returning one by one.

❌ Common Mistakes to Avoid
❌ Missing base case → Infinite loop!
❌ Not simplifying input (always do n-1, n+1, etc.)
❌ Deep recursion with huge input → May crash or freeze
❌ Ignoring time complexity

⏳ Time Complexity
For most simple recursive functions like above, the time complexity is O(n) — similar to a loop because the code block runs n times.

💬 Final Tip →
Always put the base case at the top and think about how the input changes with each call. Practice daily, and one day recursion will feel as natural as loops.

Keep practicing and keep coding! 🚀

📘 Today I Learned: Time and Space Complexity

Laxman Nemane — Mon, 21 Jul 2025 10:21:47 +0000

What is Time Complexity?
Time complexity is the measure of efficiency of an algorithm as the size of the input grows.
It tells us how many operations an algorithm takes to complete, depending on input size n.

💡 Myth: Time complexity ≠ Time taken
✅ Fact: Time taken depends on machine, language, and environment.
✅ Time complexity is theoretical—it gives a general idea of algorithm performance.

What is an Algorithm?
An algorithm is simply a step-by-step solution to a problem.

Key Insight:

Lower time complexity = Better performance
So we prefer algorithms with less complexity when solving problems.

🔍 Example: Linear Search vs Binary Search
Linear Search:
Works on both sorted and unsorted arrays

Time Complexity: O(n)

Example:


// array = [2, 3, 4, 5, 6]
// Find 4 by looping through each element
Binary Search:
Works only on sorted arrays

Time Complexity: O(log n)

Example:


// array = [2, 3, 4, 5, 6]
// Start with middle, divide in half repeatedly
Feature Linear Search   Binary Search
Input Requirement   Sorted/Unsorted Sorted only
Approach    Loop through each   Divide & conquer
Time Complexity O(n)    O(log n)

✅ Binary Search is faster and more efficient than Linear Search on sorted data.

🧠 Common Time Complexities (With Examples):
O(1) — Constant Time

Example: arr5

O(log n) — Logarithmic Time

Example: Binary Search

O(n) — Linear Time

Example: Linear Search

O(n log n) — Linearithmic Time

Example:


for (i = 0; i < n; i++) {
  binarySearch();
}

O(n²) — Quadratic Time

Example: Nested loops (e.g., bubble sort)

O(n³) — Cubic Time

Example: Three nested loops

O(2ⁿ) — Exponential Time

Example: Recursive Fibonacci

O(n!) — Factorial Time

Example: Generating all permutations

⚠️ Note: O(2ⁿ) and O(n!) are rarely used because they're very inefficient.

🔺 Time Complexity Graph:
Here’s a visual graph representing different complexities from best to worst:

Time Complexity Graph

Final Time Complexity Ranking:

O(1) < O(log n) < O(n) < O(n log n) < O(n²) < O(2ⁿ) < O(n!)

🧠 DSA Day 6

Laxman Nemane — Thu, 17 Jul 2025 05:02:55 +0000

Today was a productive day! I worked on a few fundamental JavaScript concepts that are super useful in Data Structures and Algorithms:

✅ Count Digits Program
Wrote a function to count the number of digits in a number. Practiced using loops and type conversion for this.
Example:

function countDigits(num) {
  return num.toString().length;
}
console.log(countDigits(12345)); // Output: 5

✅ Math Methods – Explored:

Math.floor(4.7) ➝ 4 (rounds down)

Math.ceil(4.2) ➝ 5 (rounds up)

Math.round(4.5) ➝ 5 (rounds to nearest)

Math.abs(-10) ➝ 10 (returns absolute value)

These methods are very handy when working with calculations, arrays, or loops.

✅ Palindrome Number
Wrote a function to check if a number reads the same backward (like 121, 1331).
Example:

function isPalindrome(num) {
  let str = num.toString();
  return str === str.split('').reverse().join('');
}
console.log(isPalindrome(121)); // Output: true
console.log(isPalindrome(123)); // Output: false

🛠️ All these basics are helping me get more comfortable with JavaScript and strengthen my logic-building skills for DSA.

🔁 Small wins each day add up. On to Day 7!

🟦 DSA Day 5

Laxman Nemane — Wed, 16 Jul 2025 11:31:47 +0000

Today I revised what I’ve learned so far and practiced for loops by solving a few star pattern problems.
It helped me recall the logic and understand how nested loops work more clearly.

⭐ Patterns I tried:
Right-angled triangle Inverted triangle Pyramid (basic)

Keeping it simple, but consistent. 💪

🧠 DSA Series - Day 4

Laxman Nemane — Fri, 11 Jul 2025 04:57:07 +0000

Simple Pattern Programs
Yesterday, I practiced some basic pattern problems using nested loops in JavaScript. Although I missed posting the update, here’s a quick recap of what I learned.

🔹 1. Square Pattern
I started with a simple square pattern where each row and column prints the same character:

 // Example 1
* * * *
* * * *
* * * *
* * * *

📌 What I learned:
**i** represents the **row**
**j** represents the **column**


for (let i = 0; i < 4; i++) {
  let row = "";
  for (let j = 0; j < 4; j++) {
    row += "* ";
  }
  console.log(row);
}

🔹 2. Incremental Number Pattern

// Example 2
1 2 3
1 2 3
1 2 3

for (let i = 1; i <= 3; i++) {
  let row = "";
  for (let j = 1; j <= 3; j++) {
    row += j + " ";
  }
  console.log(row);
}

🧩 Observation:
Again, i = rows, j = columns. The column value (j) is what’s changing inside the row.

✍️ Key Takeaway:
Understanding how nested loops work is key to solving pattern problems. The outer loop usually controls the rows, and the inner loop handles the columns.

More patterns coming soon in my DSA practice journey. Happy coding! 🚀

🧠 DSA Series - Day 3

Laxman Nemane — Wed, 09 Jul 2025 19:04:30 +0000

📌 Topic: For Loop Practice – Real-World Problems

Today is our practice session on loops. We are solving beginner-friendly problems using the for loop. Make sure to understand edge cases — this habit will save you from bugs and unexpected behaviors. 🚀

✅ 1. Find the Index of a Given Element
Problem:
Search for a specific element in an array. If it exists, return its index. If not, return -1.


function searchElement(arr, element) {
  for (let i = 0; i < arr.length; i++) {
    if (arr[i] === element) {
      return i;
    }
  }
  return -1;
}

let res = searchElement([12, 8, 4, 2, 99], 99);
console.log("Index:", res);

✅ 2. Count Positive and Negative Numbers
Problem:
Count how many positive and negative numbers are in an array.


function checkCount(arr) {
  let positiveCount = 0;
  let negativeCount = 0;

  for (let i = 0; i < arr.length; i++) {
    if (arr[i] > 0) {
      positiveCount++;
    } else {
      negativeCount++;
    }
  }

  return { positiveCount, negativeCount };
}

let res = checkCount([12, 8, 4, 2, -99]);
console.log("Counts:", res);

✅ 3. Find the Largest Number
Problem:
Find the largest number in a given array.


function findLargest(arr) {
  let largeNumber = arr[0];

  for (let i = 1; i < arr.length; i++) {
    if (arr[i] > largeNumber) {
      largeNumber = arr[i];
    }
  }

  return largeNumber;
}

let res = findLargest([12, 8, 4, 2, -99]);
console.log("Largest:", res);

✅ 4. Find the Second Largest Number
Problem:
Find the second largest number in an array.

function findSecondLargest(arr) {
  if (arr.length < 2) {
    return "Array must contain at least 2 elements";
  }

  let fl = -Infinity; // First Largest
  let sl = -Infinity; // Second Largest

  for (let i = 0; i < arr.length; i++) {
    if (arr[i] > fl) {
      sl = fl;
      fl = arr[i];
    } else if (arr[i] > sl && arr[i] !== fl) {
      sl = arr[i];
    }
  }

  return { firstLargest: fl, secondLargest: sl };
}

let res = findSecondLargest([12, 8, 4, 2, 99]);
console.log("Second Largest:", res);

🎯 Takeaway:
Always test your code for edge cases like:

Empty arrays
All elements being the same
Arrays with only negative numbers
Arrays with one element
Practicing like this strengthens your fundamentals. Stay consistent and keep building!

💬 Let me know which one was your favorite or if you faced any issues!

💻 Until tomorrow, Happy Coding! 👨‍💻✨

✅ DSA Learning – Day 2:

Laxman Nemane — Tue, 08 Jul 2025 17:55:48 +0000

Today, I learned about functions in JavaScript — how they are declared, how they work, and some basic control flow using if, else, and else if blocks.

🔹What is a Function in JavaScript?
A function is a reusable block of code that performs a specific task. You can define a function using the function keyword followed by a name and a

function greet() {
  console.log("Hello, world!");
}

You can call the function by using its name:

greet(); // Output: Hello, world!

🔹Dynamic Functions with Parameters
Functions can also accept parameters, which makes them dynamic and reusable with different inputs. For example, summing two numbers:


function sum(a, b) {
  console.log("Sum is:", a + b);
}

sum(5, 3); // Output: Sum is: 8

Here, a and b are parameters, and we passed different values (arguments) when calling the function.

🔹Returning Values from Functions
You can also return a value from a function using the return keyword:

function multiply(x, y) {
  return x * y;
}

let result = multiply(4, 5);
console.log(result); // Output: 20

🔹If / Else Conditions
I also learned about basic conditional logic using if, else, and else if:

let num = 10;

if (num > 10) {
  console.log("Greater than 10");
} else if (num === 10) {
  console.log("Equal to 10");
} else {
  console.log("Less than 10");
}

These are used to control the flow based on conditions.

🔹for loop
— what it is and how it works.
A for loop is used to perform repetitive tasks. It runs a block of code multiple times based on a condition.

The for loop has three main parts:

Initialization– where we set the starting point (e.g., let i = 0)

Condition check – the loop runs only if this condition is true

_Increment/Update _– after each iteration, the loop variable is updated (e.g., i++)

If the condition becomes false, the loop stops.

Example:


for (let i = 0; i < 5; i++) {
  console.log(i);
}
What happens here:
Initialization: let i = 0
Condition: i < 5 → if true, run the block
After printing i, increment i using i++
Repeat until i < 5 becomes false

📌 Summary

A function performs a task and can be reused.
You can pass parameters to make it dynamic.
Functions can return values.
Use if, else if, and else to control decision-making in code.

Until tomorrow, Happy coding