A beginner-friendly guide to finding the starting letters shared by every string, with a visual explanation, a complete dry run, and optimal Python, Java, and PHP solutions.

Strings | Array | Interview Preparation | Reading time: 12–15 minutes

1. Introduction

Imagine that you have three words: flower, flow and flight. All three words begin with the letters f and l. However, their next letters are different. The longest starting part shared by all three words is therefore “fl”.

This is exactly what the Longest Common Prefix problem asks us to find. A prefix is simply a group of characters at the beginning of a word. Our job is to find the longest prefix that appears at the beginning of every string in the given list.

This problem is useful because it teaches us how to compare strings, inspect characters by position, and stop as soon as a mismatch is found. Similar ideas appear in search suggestions, grouping words, autocomplete systems and text processing.

By the end of this tutorial, you will understand the problem, follow the algorithm by hand, and be able to implement it in Python, Java and PHP.

2. Problem Statement

Given an array of strings strs, write a function to find the longest common prefix string amongst the strings.

If there is no common prefix, return an empty string "".

In simple words: look at the beginning of every word and find the longest sequence of letters that is exactly the same in all of them. The matching letters must start at position zero; letters that appear later in a word do not count.

What does “prefix” mean?

A prefix is a continuous group of characters taken from the beginning of a string. For example, the prefixes of "computer" include "c", "co", "com" and "comp". The word "put" is not a prefix because it does not start at the beginning.

Constraints

• 1 <= strs.length <= 200
• 0 <= strs[i].length <= 200
• strs[i] contains only lowercase English letters if it is non-empty.

Important: A string in the array may be empty. If even one string is empty, there cannot be a non-empty common prefix, so the answer must be "".

3. Examples Explained

Example 1

Input: strs = ["flower", "flow", "flight"]

Output: "fl"

Compare the strings from left to right:

1. First character: f, f, f — all match.
2. Second character: l, l, l — all match.
3. Third character: o, o, i — not all match.

We must stop at the first mismatch. The common starting part is "fl".

Example 2

Input: strs = ["dog", "racecar", "car"]

Output: ""

The first characters are d, r and c. They are already different, so there is no common prefix. Return an empty string.

4. Understanding the Problem

What are we given?

We are given a list (array) containing one or more strings. Each string is a sequence of characters, such as "flower" or "flow".

What do we need to find?

We need the longest sequence of characters that every string shares from the very beginning.

Important observations

• Every character in the answer must match at the same position in every string.
• We must stop as soon as one string has a different character.
• We must also stop if we reach the end of any string.
• If the first character does not match, the answer is empty.

A simple real-world analogy

Think of several people reading words aloud, one letter at a time. They all say “f”, then all say “l”. At the next letter, one person says “i” while the others say “o”. The group can agree only on “fl”. That shared beginning is the longest common prefix.

5. Important Concepts Required

1. Array of strings

An array is a collection of values stored together. Here, each value is a word.

strs = ["flower", "flow", "flight"]

We use the array to visit every word and compare its characters.

2. String indexing

Each character in a string has a position called an index. In most of the languages used here, indexing starts at zero.

word = "flow"
# index:     0  1  2  3
# character: f  l  o  w

So word[0] is 'f', and word[1] is 'l'.

3. Loops and comparison

A loop repeats an action. We use one loop to move through character positions and another to check that position in every string. A comparison checks whether two characters are equal.

if strs[0][position] != strs[1][position]:
    # These two characters are different.

The actual solution checks all strings, not just the first two.

6. Approaches to Solve the Problem

Approach 1: Brute Force — Try Prefixes One by One

Basic idea: Start with a prefix of length one, then length two, then length three, and so on. For each candidate, check whether every string starts with that candidate. Keep the longest candidate that works. Stop when a candidate fails.

Step-by-step example

For ["flower", "flow", "flight"]:

1. Try "f". All words start with it, so keep it.
2. Try "fl". All words start with it, so keep it.
3. Try "flo". "flight" does not start with it, so stop.

The answer is "fl".

Pseudocode

Find the length of the shortest string.
Set answer to an empty string.
For each possible prefix length from 1 to shortest length:
    Take that many characters from the first string.
    Check whether every string starts with this candidate.
    If all strings match:
        Save the candidate as the answer.
    Otherwise:
        Stop checking longer candidates.
Return answer.

Fully commented Python code

def longestCommonPrefix(strs):
    # The shortest word puts a limit on how long
    # a common prefix can possibly be.
    shortest_length = min(len(word) for word in strs)
    # This will store the longest prefix that works.
    answer = ""
    # Try prefix lengths 1, 2, 3, ... up to the shortest word.
    for length in range(1, shortest_length + 1):
        # Take the first 'length' characters from the first word.
        candidate = strs[0][:length]
        # Check whether every word begins with this candidate.
        all_match = True
        for word in strs:
            if not word.startswith(candidate):
                all_match = False
                break
        # If every word matched, this is our new best answer.
        if all_match:
            answer = candidate
        else:
            # A longer prefix cannot work after a shorter one fails.
            break
    return answer

Time complexity: In the worst case, this approach can check many candidate prefixes against many strings. With straightforward prefix comparisons, a safe upper bound is O(N × L²), where N is the number of strings and L is the length of the shortest string.

Space complexity: Up to O(L) for candidate and answer strings, depending on the language's substring behavior.

Advantages: Very easy to understand because it tests prefixes in increasing order.

Disadvantages: It repeats comparisons for characters that were already checked in shorter prefixes.

Approach 2: Optimal — Vertical Scanning

Core intuition: Instead of building and checking many candidate prefixes, compare all strings one character position at a time. Start at position zero. If every string has the same character at that position, move to the next position. The first mismatch tells us exactly where the common prefix ends.

Why this is preferable: Each character position is examined only until the first mismatch or the end of the shortest string. We do not repeat the full prefix comparison for every possible prefix length.

Algorithm step by step

1. Choose the first string as the reference word.
2. Visit its characters from left to right, using a position counter.
3. For the current position, compare the reference character with the character at the same position in every other string.
4. If a string ends or a character differs, return the part of the reference word before this position.
5. If all positions match, return the whole reference word.

Pseudocode

If the input list is empty:
    Return an empty string.
Use the first string as the reference word.
For each character position in the reference word:
    For each string in the list:
        If this string has ended:
            Return the reference word before this position.
        If its character at this position differs from the reference:
            Return the reference word before this position.
Return the complete reference word.

Why does it work?

A common prefix must match at position zero, then position one, then position two, and so on without skipping a position. Therefore, the first position where any string differs is the exact point where the shared prefix ends. No character after that position can extend the common prefix.

Time complexity: O(N × L) in the worst case, where N is the number of strings and L is the length of the shortest string (or reference string if all strings are at least that long). More precisely, the algorithm performs at most one comparison per string per visited position.

Auxiliary space complexity: O(1), excluding the returned prefix. The algorithm uses only a few counters and references.

9. Pseudocode

FUNCTION longestCommonPrefix(list of words):
    IF the list is empty:
        RETURN ""
    reference = first word in the list
    FOR each position from 0 to the end of reference:
        expectedCharacter = character at this position in reference
        FOR each word in the list:
            IF position is beyond the end of word:
                RETURN reference from beginning up to this position
            IF word's character at this position is not expectedCharacter:
                RETURN reference from beginning up to this position
    RETURN reference

The pseudocode is intentionally written in plain language. The Python, Java and PHP versions below follow the same checks.

10. Code Implementations in Multiple Programming Languages

Python

Approach: Optimal vertical scanning.

Explanation: We use the first word as the reference. For each character in it, we inspect that same position in every word. If a word is too short or its character is different, we return the reference word up to the current position.

Complete Python codeCopy code

class Solution:
    def longestCommonPrefix(self, strs):
        # The problem guarantees at least one string,
        # but this check also makes the function safe for an empty list.
        if not strs:
            return ""
        # Use the first word as our reference for comparison.
        first_word = strs[0]        # Move through the reference word one character at a time.
        for position in range(len(first_word)):
            # This is the character every other word must have here.
            expected_character = first_word[position]
            # Compare this position in every word.
            for word in strs:
                # If this word has no character at this position,
                # it is shorter than the reference word.
                if position >= len(word):
                    # Return all reference characters before this position.
                    return first_word[:position]
                # If the character is different, the common prefix ends here.
                if word[position] != expected_character:
                    return first_word[:position]
        # If no mismatch was found, the entire first word is common.
        return first_word

# Example:
solution = Solution()
print(solution.longestCommonPrefix(["flower", "flow", "flight"]))
# Output: fl

Example execution: Input: ["flower", "flow", "flight"] → Output: "fl".

Complexity: Time O(N × L); auxiliary space O(1), excluding the returned substring.

Java

Approach: Optimal vertical scanning.

Explanation: Java strings use zero-based character positions too. We read the reference character with charAt(position), then compare it with the same position in every string. We check the string length first so that we never try to read a character beyond its end.

Complete Java codeCopy code

class Solution {
    public String longestCommonPrefix(String[] strs) {
        // Safety check: if there are no words, there is no common prefix.
        if (strs == null || strs.length == 0) {
            return "";
        }
        // Use the first word as the reference word.
        String firstWord = strs[0];
        // Visit each character position in the reference word.
        for (int position = 0; position < firstWord.length(); position++) {
            // Store the character that all words must match at this position.
            char expectedCharacter = firstWord.charAt(position);
            // Check this same position in every word.
            for (String word : strs) {
                // If the current word is too short, the prefix ends here.
                if (position >= word.length()) {
                    return firstWord.substring(0, position);
                }
                // If the character does not match, return the prefix so far.
                if (word.charAt(position) != expectedCharacter) {
                    return firstWord.substring(0, position);
                }
            }
        }
        // Every character of the reference word matched in all words.
        return firstWord;
    }
}
// Example use:
// Solution solution = new Solution();
// System.out.println(solution.longestCommonPrefix(
//     new String[] {"flower", "flow", "flight"}
// ));
// Output: fl

Example execution: Input: ["flower", "flow", "flight"] → Output: "fl".

Complexity: Time O(N × L); auxiliary space O(1), excluding the returned substring.

PHP

Approach: Optimal vertical scanning.

Explanation: PHP strings can be accessed by character position using square brackets for the lowercase English letters in this problem. We check that the position exists before comparing it. When a mismatch occurs, substr() returns the matching beginning portion.

Complete PHP codeCopy code

<?php
class Solution {
    function longestCommonPrefix($strs) {
      // If the list is empty, return an empty string.
        if (empty($strs)) {
            return "";
        }
        // Select the first word as the reference word.
        $firstWord = $strs[0];
        // Check each character position in the reference word.
        for ($position = 0; $position < strlen($firstWord); $position++) {
            // This is the character every word should have at this position.
            $expectedCharacter = $firstWord[$position];
            // Compare the same position in each word.
            foreach ($strs as $word) {
                // If the word has ended, the common prefix ends here.
                if ($position >= strlen($word)) {
                    return substr($firstWord, 0, $position);
                }
                // If this character is different, return the prefix so far.
                if ($word[$position] !== $expectedCharacter) {
                    return substr($firstWord, 0, $position);
                }
            }
        }
        // No mismatch occurred, so the complete first word is common.
        return $firstWord;
    }
}
// Example:
// $solution = new Solution();
// echo $solution->longestCommonPrefix(["flower", "flow", "flight"]);
// Output: fl
?>

Example execution: Input: ["flower", "flow", "flight"] → Output: "fl".

Complexity: Time O(N × L); auxiliary space O(1), excluding the returned substring. The problem restricts input to lowercase English letters, so PHP byte-based string indexing is suitable here.

11. Time and Space Complexity Analysis

Let N be the number of strings and L be the length of the shortest string. The algorithm cannot need to inspect more than L positions, because a common prefix cannot be longer than the shortest word.

ApproachTime complexityAuxiliary spaceReasonBrute force: test each prefixO(N × L²) upper boundO(L) depending on substring copiesThere can be L candidate prefixes, and checking each can inspect up to L characters in each of N strings.Optimal: vertical scanningO(N × L)O(1)At most L positions are checked across N strings, with no growing auxiliary data structure.

Best, average and worst cases

• Best case: The first character differs in at least one string. Only the first position needs to be checked, so the work is proportional to the number of strings: O(N).
• Average case: The number of positions checked depends on where the first mismatch occurs. If it occurs after K matching positions, the work is at most proportional to N × (K + 1).
• Worst case: All strings match for the entire length of the shortest string. The algorithm checks up to N × L characters.

Space note: Auxiliary space describes temporary working memory and does not count the answer returned by the function. Some languages may allocate memory for the returned substring.

12. Edge Cases

InputExpected outputWhy?["flower", "flow", "flight"]"fl"The first two positions match in every word.["dog", "racecar", "car"]""The first characters are different.["alone"]"alone"With one word, the whole word is its own longest common prefix.["", "abc"]""An empty string has no starting characters to share.["same", "same", "same"]"same"All strings are identical.["ab", "a"]"a"The shorter string limits the prefix length.["a", "b"]""The first position already differs.["prefix", "pre", "prevent"]"pre"The shortest word ends after the shared letters.

13. Common Mistakes

• Comparing letters anywhere in the words: A common prefix must begin at index zero. Do not search for matching letters in the middle.
• Continuing after a mismatch: Once one character position differs, no longer prefix can be valid. Return immediately.
• Ignoring shorter strings: A word may end before the reference word. Check its length before reading the character.
• Returning the shortest word automatically: The shortest word is only an upper limit. It may not match the beginning of the other words.
• Confusing prefix with substring: A substring can appear anywhere; a prefix must start at the beginning.
• Off-by-one errors: The mismatch position itself must not be included. That is why we return characters from index zero up to, but not including, the current position.
• Using unsafe indexing in Java: Check position < word.length() before calling charAt(position).

14. Interview Preparation

Why do interviewers ask this?

This is a compact way to test whether you understand strings, arrays, indexing, nested loops, early stopping and complexity analysis. It also reveals whether you handle shorter strings and mismatches safely.

How to explain the optimal solution in an interview

“I will scan the strings vertically, one character position at a time. I will use the first string as a reference and compare its character at the current position with the same position in every other string. If a string ends or any character differs, I will return the reference string before that position. If I finish the reference string without finding a mismatch, the entire reference string is the answer. The time complexity is O(N × L), and the auxiliary space is O(1).”

Possible follow-up questions

• How would you solve this if the strings arrive one at a time as a stream?
• How would you handle uppercase letters, punctuation or Unicode characters?
• Can you solve the problem by sorting the strings first?
• What changes if the array contains millions of strings?
• How would you find the longest common suffix instead of prefix?

Related variations to practise

• Longest Common Substring
• Longest Common Subsequence
• Implement Trie (Prefix Tree)
• Search Suggestions System

15. Frequently Asked Questions

1. What is a common prefix?

It is a sequence of characters that appears at the beginning of every string in the list.

2. What should we return if no prefix exists?

Return an empty string: "".

3. Why do we use the first string as the reference?

It gives us a convenient sequence of positions to inspect. Any common prefix must also be a prefix of this first string.

4. Why do we stop at the first mismatch?

A prefix cannot skip a character. If one position does not match, no longer starting sequence can match all strings.

5. Can the answer be the entire first string?

Yes. If every other string begins with the complete first string, then the first string is the longest common prefix.

6. What is the optimal time complexity?

O(N × L) in the worst case, where N is the number of strings and L is the length of the shortest string.

7. Does the order of strings change the answer?

No. The common prefix is the same regardless of order. We use the first string only as a convenient reference.

16. Conclusion

The Longest Common Prefix problem asks us to find the longest sequence of starting characters shared by every string. The key observation is that we only need to compare characters at the same position. As soon as a mismatch occurs or a string ends, the answer is known.

The vertical scanning approach is simple, efficient and easy to explain in an interview. It takes O(N × L) time in the worst case and uses O(1) auxiliary space, excluding the returned answer.

Key takeaway: Compare from left to right, check every string at the same position, and stop at the first mismatch.

Practise this pattern with other string problems to become more confident with arrays, indexing and character comparisons. If this tutorial helped you, share it with a friend who is learning DSA and leave a comment with the next problem you would like explained.

🗓️ Day 4 at ENATS

Date: Thursday, June 19, 2025

📌 Morning Arrival & Task Overview

I arrived at 9:30 AM and began working on OpenCart — an open-source e-commerce platform. It’s equipped with built-in modules, making setup and configuration quite straightforward for online storefronts.

⚙️ OpenCart 4.0.3 Setup

My first mission was to fully install and configure OpenCart 4.0.3. I reviewed the official documentation and got hands-on guidance from colleagues. Here’s the step-by-step process:

1. Download OpenCart 4.0.3 ZIP and extract it.
2. Copy the upload folder into htdocs, renaming it opencart.
3. Create a new database via localhost/phpMyAdmin.
4. Navigate to localhost/opencart in the browser:

• Follow the installer prompts.
• Address permission issues by creating/moving folders, deleting unnecessary files, and renaming config files as instructed.

1. Once completed, the admin dashboard and storefront went live without errors.

🏷️ Adding manufacturer_code Field

My next task: add a new custom field — manufacturer_code—to the Manufacturers admin list.

Steps undertaken:

• Modified the database schema to include the new column in the manufacturers table.
• Updated the manufacturer form:
• Added manufacturer_code input in the add/edit form template.
• Ensured it’s displayed and saved correctly.
• Refreshed the admin list to show the new column.
• Performed thorough testing to verify insertion, editing, display, and saving of the new field.

I wrapped everything up by day’s end — database, forms, controller, and admin listing are all fully integrated and functional.

📝 Summary of Achievements

• ✅ OpenCart 4.0.3 successfully installed and configured.
• ✅ Created and assigned a database, resolved file permissions.
• ✅ Added manufacturer_code field across database, admin form, controller, and list display.
• ✅ Completed testing — form, save, display, and update all working smoothly.

💬 Reflection & Next Steps

Today’s focus on platform setup and schema extension taught me a lot about:

• Handling file and config adjustments during E Commerce setups.
• Extending OpenCart’s core components to add custom data fields.
• Ensuring end-to-end functionality from database to admin UI.

Tomorrow, I plan to build out front-end integration for the new field, making it visible in product listings and storefront filters.

🔍 Want to Know More?

Curious about how I adjusted the database schema, modified the Twig admin template, or updated the controller logic?
Comment below and I’d be happy to share the code snippets and techniques I used!

Hello everyone and welcome! 👋

Here’s a detailed and organized update on my third day at ENATS, building out API endpoints with token-based authentication 🚀

🗓️ Day 3 at ENATS

Date: Wednesday, June 18, 2025

Morning Sessions

• Arrived at 9:30 AM and carried forward the API work from yesterday.
• Focused on authentication routes located in routes/api.php.
• Thoroughly tested routes both with and without a token, ensuring correct responses
• All authentication logic resides in my AuthController.

🔄 CRUD API Routes Implemented

Following successful authentication testing, I created several essential endpoints:

Endpoint Method Functionality /post GET Fetch all blog posts of an authenticated user /post POST Create a new post (authentication required) /post/{id} GET Retrieve a specific post /post/update/{id} PUT Update a specific post /post/{id} DELETE Delete a specific post

Afternoon: Testing & Fixes

• Rigorous testing on each route using Postman
• Encountered several issues during method implementation.
• Debugged and resolved routing bugs and controller logic mishaps.
• Made updates to internal controller files and API Resource handling.

🌙 Evening Wrap-Up

• Successfully built and tested the full authentication system.
• All CRUD operations for Post are functional and secured.
• Finalized the first version of the API; ready to build more features tomorrow.

📌 Key Takeaways & Resources

1. Laravel Sanctum provides a lightweight method for token-based API authentication. The typical flow:

• Install Sanctum, publish config, migrate.
• Add HasApiTokens to the User model.
• Use auth:sanctum middleware to protect routes.

1. Protecting routes:

e Anything

Curious about how I approached authentication, token validation, or debugging?
Drop your questions below — I’d love to dive deeper into any part of the setup!

I appreciate your support and interest! Let’s keep building 💪

Today, I embarked on my first trial day at a small firm with a team of 10. After a successful interview, I was eager to dive into real-world development tasks. Here’s a detailed account of my day:

Morning Session: Implementing Pagination in a CRUD Application

My day began at 9:30 AM amidst heavy rainfall. Upon arrival, I observed the team working diligently. After a brief period, I approached my supervisor to inquire about my tasks. He assigned me the responsibility of adding pagination to an existing CRUD application — a project I had worked on during the interview.

To efficiently manage a large dataset, I utilized Laravel’s seeder functionality to generate fake data. This allowed me to populate the database with sufficient records for testing pagination.

For pagination, I employed Laravel’s paginate() method to limit the number of records displayed per page. To enhance the user interface, I integrated Bootstrap 5 pagination by calling the links() method in the view, ensuring a seamless and responsive pagination experience.

Code Snippet:

// In Controller
$posts = Post::paginate(10);
// In Blade View
{{ $posts->links('pagination::bootstrap-5') }}

Afternoon Session: Diving into API Development

Post-lunch, I was tasked with learning about API development — a domain I was unfamiliar with. I dedicated the remainder of the day to studying Laravel’s documentation and exploring ChatGPT for guidance.

In Laravel 12, the api.php route file isn't included by default. To set up API routes, I manually created the routes/api.php file and registered it in bootstrap/app.php.

Steps to Set Up API Routes:

1. Create the api.php File:

php artisan make:controller Api/PostController

2. Define API Routes:

// In routes/api.php use App\Http\Controllers\Api\PostController; 
Route::apiResource('posts', PostController::class);

3. Register the api.php File:

// In bootstrap/app.php 
$app->withRouting(
     web: __DIR__.'/../routes/web.php',
     api: __DIR__.'/../routes/api.php',
     commands: __DIR__.'/../routes/console.php', );

1. Create Model, Migration, and Controller:

php artisan make:model Post -mcr

1. Update Migration File:

public function up() {
     Schema::create('posts', function (Blueprint $table) 
{
         $table->id();
         $table->string('title');
         $table->text('body');
         $table->timestamps();
     });
 }

1. Define Controller Methods:

public function index() {
     return Post::all();
 }
  public function store(Request $request) {
     $data = $request->validate([
         'title' => 'required|string',
         'body' => 'required|string',
     ]);
     return Post::create($data);
 }

By the end of the day, I had successfully set up basic API routes and operations. The next step involves implementing token-based authentication, which I plan to tackle in the coming days.

Conclusion:

My first trial day was both challenging and rewarding. I gained hands-on experience with Laravel’s pagination system and initiated my journey into API development. I’m excited about the learning opportunities ahead and look forward to contributing more to the team.

Whether it’s a form submission, a dynamic link, or redirecting with values — Laravel makes it super simple. In this post, I’ll walk you through how to pass data via URL in Laravel, how to retrieve it, and where to write the code. 🙌

🧠 What You’ll Learn

• How to create routes that pass data
• How to send data via URL (GET)
• How to retrieve that data in a controller or view
• Real-world example with step-by-step code
• What the output will look like

🛠 Step 1: Set Up a Fresh Laravel Project (Optional)

If you’re just testing this out:

laravel new url-passing-demo
cd url-passing-demo
php artisan serve

Or use an existing Laravel project.

📁 Step 2: Create Two Routes in web.php

Let’s say we want to go from:

• Page 1: http://localhost:8000/user/John/21
• To show: "Hello John, your age is 21"

Open routes/web.php and add:

use Illuminate\Support\Facades\Route;
Route::get('/user/{name}/{age}', function ($name, $age) {
    return view('user', ['name' => $name, 'age' => $age]);
});

✅ What’s happening here?

• {name} and {age} are route parameters.
• When you visit this URL → localhost:8000/user/John/21, it grabs:
• $name = John
• $age = 21
• Then it sends them to the user.blade.php view.

🧾 Step 3: Create a View File (resources/views/user.blade.php)

Now let’s display that data:

<!-- resources/views/user.blade.php -->
<!DOCTYPE html>
<html>
<head>
    <title>User Info</title>
</head>
<body>
    <h1>Hello {{ $name }}, your age is {{ $age }}!</h1>
</body>
</html>

✅ Output when you visit http://localhost:8000/user/John/21:

Hello John, your age is 21!

💡 You can change the name and age directly in the URL:
/user/Aisha/30 → "Hello Aisha, your age is 30!"

🧭 Step 4: Link to Another URL with Data

Let’s say you’re on a home page and want to redirect to a user page with data.

In web.php:

Route::get('/', function () {
    $name = "Rahul";
    $age = 25;
    return redirect()->route('user.info', ['name' => $name, 'age' => $age]);
});
Route::get('/user/{name}/{age}', function ($name, $age) {
    return view('user', compact('name', 'age'));
})->name('user.info');

✅ Here, we’re:

• Defining a named route: user.info
• Redirecting to that route with parameters name and age

🎯 Bonus: Passing Data Using Query String (e.g., ?name=John&age=22)

In web.php:

Route::get('/show', function (Illuminate\Http\Request $request) {
    $name = $request->query('name');
    $age = $request->query('age');
    return "Hi $name, you are $age years old!";
});

Now visit:
➡️ http://localhost:8000/show?name=Ravi&age=22
📋 Output:

Hi Ravi, you are 22 years old!

🎁 Real-Life Use Case

Imagine you’re on a user list page, and when you click on a user, you want to go to a details page:

<!-- user-list.blade.php -->
@foreach($users as $user)
    <a href="{{ url(https://medium.com/'/user/'.$user->name.'/'.$user->age) }}">
        {{ $user->name }}
    </a><br>
@endforeach

Clicking that will take you to:
/user/John/23 → and show "Hello John, your age is 23!"

✅ Final Thoughts

Laravel makes it easy to pass data through routes using:

• Route Parameters (clean and RESTful)
• Query Strings (for optional values or filters)
• Redirects and Named Routes (for structured control)

Once you get the hang of this, you’ll start building dynamic pages, profile views, product details, and much more in no time. 💪

Difficulty: Easy
LeetCode Problem #13

Whether you’re prepping for coding interviews or brushing up your algorithm skills, converting Roman numerals to integers is a classic problem worth mastering. Let’s walk through the logic, break it down step-by-step, and solve it using PHP, Python, Java, and JavaScript.

📜 What Are Roman Numerals?

Roman numerals are made up of seven symbols:

Symbol Value I 1 V 5 X 10 L 50 C 100 D 500 M 1000

Generally, symbols are placed from largest to smallest from left to right. But there are six special subtraction cases:

• I before V or X → 4 (IV), 9 (IX)
• X before L or C → 40 (XL), 90 (XC)
• C before D or M → 400 (CD), 900 (CM)

🧠 Problem Statement

Given a Roman numeral as a string, convert it to an integer.

🔍 Strategy

1. Create a mapping of Roman symbols to their values.
2. Loop through the string:

• Compare current symbol with the next one.
• If current >= next → add it.
• If current < next → subtract it.

1. Sum everything and return the result.

🔎 Example: "MCMXCIV"

M(1000) + CM(900) + XC(90) + IV(4) = 1994

🧑‍💻 PHP Code

class Solution {
    function romanToInt($s) {
        $roman = [
            'I'=> 1, 'V'=> 5, 'X'=>10,
            'L'=>50, 'C'=>100, 'D'=>500, 'M'=>1000
        ];
        $length = strlen($s);
        $total = 0;
        for ($i = 0; $i < $length; $i++) {
            $current = $roman[$s[$i]];
            $next = $roman[$s[$i + 1]] ?? 0;
            if ($current >= $next) {
                $total += $current;
            } else {
                $total -= $current;
            }
        }
        return $total;
    }
}

🐍 Python Code

class Solution:
    def romanToInt(self, s: str) -> int:
        roman = {
            'I': 1, 'V': 5, 'X': 10,
            'L': 50, 'C': 100, 'D': 500, 'M': 1000
        }
        total = 0
        for i in range(len(s)):
            current = roman[s[i]]
            next_val = roman[s[i + 1]] if i + 1 < len(s) else 0
            if current >= next_val:
                total += current
            else:
                total -= current
        return total

☕ Java Code

class Solution {
    public int romanToInt(String s) {
        Map<Character, Integer> roman = Map.of(
            'I', 1, 'V', 5, 'X', 10,
            'L', 50, 'C', 100, 'D', 500, 'M', 1000
        );
        int total = 0;
        for (int i = 0; i < s.length(); i++) {
            int current = roman.get(s.charAt(i));
            int next = (i + 1 < s.length()) ? roman.get(s.charAt(i + 1)) : 0;
            if (current >= next) {
                total += current;
            } else {
                total -= current;
            }
        }
        return total;
    }
}

🌐 JavaScript Code

var romanToInt = function(s) {
    const roman = {
        'I': 1, 'V': 5, 'X': 10,
        'L': 50, 'C': 100, 'D': 500, 'M': 1000
    };
    let total = 0;
    for (let i = 0; i < s.length; i++) {
        let current = roman[s[i]];
        let next = roman[s[i + 1]] || 0;
        if (current >= next) {
            total += current;
        } else {
            total -= current;
        }
    }
    return total;
};

📈 Complexity

• Time: O(n), where n is the length of the string
• Space: O(1), constant space for the map

🎯 Final Thoughts

The Roman to Integer problem is not just a string parsing exercise — it teaches you:

• The power of hash maps
• Simple greedy algorithms
• Conditional logic in iterative loops

Understanding this will make future parsing or conversion problems easier to grasp. Add it to your toolkit of interview essentials!

🛠️ How to Create & Run Your First Laravel Project (Step-by-Step Guide)

✅ Step 1: Install Laravel

⚠️ You must have Composer and PHP (8.1 or higher) already installed.

If not installed:

• Composer: https://getcomposer.org/
• PHP: https://windows.php.net/download

You can check using:

php -v
composer -v

✅ Step 2: Create Your First Project

Open Command Prompt or Terminal, then run:

laravel new my-app

• my-app is your project name. You can use any name, e.g., laravel-blog, my-store, etc.
• This command downloads Laravel and sets up the whole folder structure.

If laravel command doesn’t work, install Laravel globally:

composer global require laravel/installer
or
composer create-project --prefer-dist laravel/laravel project-name

🔄 It might ask for:

• Database: choose MySQL
• Testing: choose Pest or PHPUnit
• Frontend stack: pick whatever is recommended or skip for now

✅ Step 3: Open Project in VS Code

Go to the folder:

cd my-app

Now open it in VS Code: The below command will open your current project in VS code

code .

✅ Step 4: Run the Project

In the VS Code open terminal or any command prompt, run:

php artisan serve

✅ This will start a development server at:

http://127.0.0.1:8000

Open that URL in your browser. You will see the Laravel welcome page.

✅ Step 5: How is the Welcome Page Working?

Here’s how Laravel connects everything:

🧩 routes/web.php

This file contains route definitions.

Default route looks like:

Route::get('/', function () {
    return view('welcome');
});

• / means homepage.
• It means that whenever you write “/” in your url and enter it will return you the page mentioned in this view(‘welcome’).
• It returns the view called welcome.

🧩 resources/views/welcome.blade.php

This is the HTML file you see in the browser. You can edit this file and refresh the browser to see changes.

🧪 Example:

Let’s say you want to make a new page called about.

1. Create a new file: resources/views/about.blade.php

<!DOCTYPE html>
 <html>
 <head>
<title>About Page</title>
</head> 
<body> 
    <h1>About Laravel Project</h1>
 </body>
 </html>

1. Add this in web.php:

Route::get('/about', function () {
    return view('about');
});

1. Now open your browser and visit:
   👉 http://127.0.0.1:8000/about

You’ll see your new page!

LeetCode’s Palindrome Number Problem

Ever wondered if a number reads the same forwards and backward? That’s the essence of a palindrome! Today, we’re going to tackle a classic coding challenge that popped up on our screen: LeetCode’s “9. Palindrome Number.”

What’s the Problem All About?

The challenge is straightforward: given an integer x, determine if it's a palindrome.

• Example 1: x = 121
• Reads 121 from left to right.
• Reads 121 from right to left.
• Output: true (It's a palindrome!)
• Example 2: x = -121
• Reads -121 from left to right.
• Reads 121- from right to left.
• Output: false (Not a palindrome, because of the negative sign!)
• Example 3: x = 10
• Reads 10 from left to right.
• Reads 01 from right to left.
• Output: false (Not a palindrome!)

The Simple Approach (and Why It’s Often a Good Start!)

The most intuitive way to solve this problem is to convert the number into a string and then check if the string is the same when reversed.

Let’s break down the logic:

1. Handle Negative Numbers: Any negative number cannot be a palindrome. Why? Because the negative sign breaks the symmetry. -121 becomes 121- when reversed. So, if x is less than 0, we immediately return false.
2. Convert to String: Transform the integer into its string representation. This makes it easy to reverse.
3. Reverse the String: Reverse the newly created string.
4. Compare: Compare the original string with the reversed string. If they are identical, then the number is a palindrome!

Optimized Code (with Comments!)

While the string conversion method is easy to understand, we can often do better, especially in interviews. A more optimized approach involves reversing half of the number without converting it to a string, avoiding extra memory allocation.

PHP

<?php
class Solution {
    /**
     * @param Integer $x
     * @return Boolean
     */
    function isPalindrome($x) {
        // Step 1: Handle negative numbers. Negative numbers cannot be palindromes.
        if ($x < 0) {
            return false;
        }
        // Step 2: Convert the integer to a string.
        $original = strval($x);
        // Step 3: Reverse the string.
        $reversed = strrev($original);
        // Step 4: Compare the original and reversed strings.
        return $original === $reversed;
    }
}
// --- Optimized PHP Solution (without string conversion for numbers) ---
class OptimizedSolution {
    /**
     * @param Integer $x
     * @return Boolean
     */
    function isPalindrome($x) {
        // Edge cases:
        // 1. Negative numbers are not palindromes.
        // 2. Numbers ending in 0 (except 0 itself) cannot be palindromes
        //    because the reversed number would start with 0.
        if ($x < 0 || ($x % 10 == 0 && $x != 0)) {
            return false;
        }
        $revertedNumber = 0;
        // Keep looping as long as the original number is greater than the reverted number.
        // This effectively reverses only half of the number.
        while ($x > $revertedNumber) {
            // Get the last digit of x and append it to revertedNumber.
            $revertedNumber = $revertedNumber * 10 + ($x % 10);
            // Remove the last digit from x.
            $x = (int)($x / 10); // Use (int) for integer division
        }
        // When the length of the number is odd, the middle digit will be in the original x,
        // so we divide revertedNumber by 10 to remove the last digit (which is the middle digit).
        // If the length is even, x and revertedNumber will be equal.
        return $x == $revertedNumber || $x == (int)($revertedNumber / 10);
    }
}
?>

Java

class Solution {
    public boolean isPalindrome(int x) {
        // Step 1: Handle negative numbers. Negative numbers cannot be palindromes.
        if (x < 0) {
            return false;
        }
// Step 2: Convert the integer to a string.
        String original = String.valueOf(x);
        // Step 3: Reverse the string.
        StringBuilder reversed = new StringBuilder(original).reverse();
        // Step 4: Compare the original and reversed strings.
        return original.equals(reversed.toString());
    }
}
// --- Optimized Java Solution (without string conversion) ---
class OptimizedSolutionJava {
    public boolean isPalindrome(int x) {
        // Edge cases:
        // 1. Negative numbers are not palindromes.
        // 2. Numbers ending in 0 (except 0 itself) cannot be palindromes
        //    because the reversed number would start with 0.
        if (x < 0 || (x % 10 == 0 && x != 0)) {
            return false;
        }
        int revertedNumber = 0;
        // Keep looping as long as the original number is greater than the reverted number.
        // This effectively reverses only half of the number.
        while (x > revertedNumber) {
            // Get the last digit of x and append it to revertedNumber.
            revertedNumber = revertedNumber * 10 + x % 10;
            // Remove the last digit from x.
            x /= 10;
        }
        // When the length of the number is odd, the middle digit will be in the original x,
        // so we divide revertedNumber by 10 to remove the last digit (which is the middle digit).
        // If the length is even, x and revertedNumber will be equal.
        return x == revertedNumber || x == revertedNumber / 10;
    }
}

Python

class Solution:
    def isPalindrome(self, x: int) -> bool:
        # Step 1: Handle negative numbers. Negative numbers cannot be palindromes.
        if x < 0:
            return False
# Step 2: Convert the integer to a string.
        original = str(x)
        # Step 3: Reverse the string. Python's slicing is very concise for this.
        reversed_str = original[::-1]
        # Step 4: Compare the original and reversed strings.
        return original == reversed_str
# --- Optimized Python Solution (without string conversion) ---
class OptimizedSolutionPython:
    def isPalindrome(self, x: int) -> bool:
        # Edge cases:
        # 1. Negative numbers are not palindromes.
        # 2. Numbers ending in 0 (except 0 itself) cannot be palindromes
        #    because the reversed number would start with 0.
        if x < 0 or (x % 10 == 0 and x != 0):
            return False
        reverted_number = 0
        # Keep looping as long as the original number is greater than the reverted number.
        # This effectively reverses only half of the number.
        while x > reverted_number:
            # Get the last digit of x and append it to reverted_number.
            reverted_number = reverted_number * 10 + x % 10
            # Remove the last digit from x (integer division).
            x //= 10
        # When the length of the number is odd, the middle digit will be in the original x,
        # so we divide reverted_number by 10 to remove the last digit (which is the middle digit).
        # If the length is even, x and reverted_number will be equal.
        return x == reverted_number or x == reverted_number // 10

JavaScript

/**
 * @param {number} x
 * @return {boolean}
 */
var isPalindrome = function(x) {
    // Step 1: Handle negative numbers. Negative numbers cannot be palindromes.
    if (x < 0) {
        return false;
    }
// Step 2: Convert the integer to a string.
    let original = String(x);
    // Step 3: Reverse the string.
    let reversed = original.split('').reverse().join('');
    // Step 4: Compare the original and reversed strings.
    return original === reversed;
};
// --- Optimized JavaScript Solution (without string conversion) ---
/**
 * @param {number} x
 * @return {boolean}
 */
var isPalindromeOptimized = function(x) {
    // Edge cases:
    // 1. Negative numbers are not palindromes.
    // 2. Numbers ending in 0 (except 0 itself) cannot be palindromes
    //    because the reversed number would start with 0.
    if (x < 0 || (x % 10 === 0 && x !== 0)) {
        return false;
    }
    let revertedNumber = 0;
    // Keep looping as long as the original number is greater than the reverted number.
    // This effectively reverses only half of the number.
    while (x > revertedNumber) {
        // Get the last digit of x and append it to revertedNumber.
        revertedNumber = revertedNumber * 10 + (x % 10);
        // Remove the last digit from x (integer division).
        x = Math.floor(x / 10);
    }
    // When the length of the number is odd, the middle digit will be in the original x,
    // so we divide revertedNumber by 10 to remove the last digit (which is the middle digit).
    // If the length is even, x and revertedNumber will be equal.
    return x === revertedNumber || x === Math.floor(revertedNumber / 10);
};

Explaining the Optimized Approach (The “Reverse Half” Method)

The optimized solutions above avoid string conversions by playing with numbers directly. Here’s a breakdown:

1. Initial Checks:

• Just like before, negative numbers are out.
• A new crucial check: if a number ends in 0 (like 120), and it's not 0 itself, it cannot be a palindrome. Why? Because its reverse would start with 0 (e.g., 021), which is not how numbers are typically represented. 0 itself is a palindrome.

1. Reversing Half the Number:

• We use a while loop that continues as long as x (our original number) is greater than revertedNumber.
• Inside the loop:
• revertedNumber = revertedNumber * 10 + x % 10;: This line does two things:
• x % 10 extracts the last digit of x.
• revertedNumber * 10 shifts the existing revertedNumber one place to the left, making space for the new digit.
• We then add the extracted last digit to revertedNumber.
• x = (int)(x / 10); (or x //= 10 in Python, x /= 10 in Java/JS): This line removes the last digit from x, effectively "shortening" the original number.

1. The Comparison:

• The loop stops when x becomes less than or equal to revertedNumber. At this point, we've effectively reversed half of the original number.
• Case 1: Even Number of Digits: If the original number had an even number of digits (e.g., 1221), the loop will stop when x becomes equal to revertedNumber (e.g., x becomes 12, revertedNumber becomes 12). In this case, x == revertedNumber will be true.
• Case 2: Odd Number of Digits: If the original number had an odd number of digits (e.g., 12321), the loop will stop when x has one more digit than revertedNumber (e.g., x becomes 12, revertedNumber becomes 123). The middle digit is now in revertedNumber. To account for this, we check x == (int)(revertedNumber / 10). Dividing revertedNumber by 10 removes its last digit (the middle digit), allowing us to compare the remaining halves.

This optimized approach is generally preferred as it avoids the overhead of string conversions and can be more efficient for very large numbers.

Why Does This Matter?

Understanding problems like “Palindrome Number” is crucial for several reasons:

• Foundation of Algorithms: It teaches fundamental concepts like number manipulation, string operations, and conditional logic.
• Problem-Solving Skills: Breaking down a problem into smaller, manageable steps is a core skill for any programmer.
• Interview Preparation: These types of questions are common in technical interviews, assessing your analytical thinking and coding proficiency.
• Optimization: Learning to go beyond the most straightforward solution and think about efficiency is a valuable habit.

So, the next time you encounter a number, take a moment to ponder: is it a palindrome? With these techniques, you’re well-equipped to find out! Happy.

One of the classic coding interview questions is the Reverse Integer problem. It’s a great problem to practice integer manipulation and boundary checking.

🧩 Problem Statement

Given a signed 32-bit integer x, return x with its digits reversed.
If reversing x causes the value to go outside the signed 32-bit integer range [-2³¹, 2³¹ - 1], return 0.

✅ Examples

• Input: 123 → Output: 321
• Input: -123 → Output: -321
• Input: 120 → Output: 21

⚠️ Constraints

A signed 32-bit integer means the number must lie within:

-2,147,483,648 to 2,147,483,647

If the reversed number exceeds this range, we return 0.

👣 Step-by-Step Approach

1. Check if the number is negative.
2. Take the absolute value of the number and reverse the digits.
3. Convert the reversed string back to an integer.
4. If the reversed number exceeds the 32-bit signed range, return 0.
5. Otherwise, return the reversed number, keeping the sign correct.

🧪 Test Cases

Input — — — — →Output

123 — — — — — —>321

-123 — — — — — → -321

120 — — — — — → 12

1534236469 — → 0

💡 PHP Solution

class Solution {
    function reverse($x) {
        // Check if the number is negative
        $isNegative = $x < 0;
// Convert the number to positive and then to a string, reverse it
        $reverseNum = strrev(strval(abs($x)));
        // Convert the reversed string back to an integer
        $rev = (int)$reverseNum;
        // If the reversed number is more than 32-bit limit, return 0
        if ($rev > 2147483647) {
            return 0;
        }
        // If original number was negative, return negative reversed number
        return $isNegative ? -$rev : $rev;
    }
}

✅ Explanation

• abs($x) removes the negative sign.
• strrev(strval(...)) reverses the number.
• Type cast back to integer using (int).
• Check overflow before returning.

🐍 Python Solution

def reverse(x):
    # Check if number is negative (less than 0)
    negative = x < 0
    # Get the absolute value (e.g., -123 becomes 123)
    x = abs(x)
    # Convert number to string, reverse it, then turn it back into integer
    reversed_x = int(str(x)[::-1])
    # If reversed number is more than allowed 32-bit max value, return 0
    if reversed_x > 2**31 - 1:
        return 0
    # Add the negative sign back if original number was negative
    return -reversed_x if negative else reversed_x

✅ Explanation

• We reverse the number using Python slicing [::-1].
• Overflow is handled by comparing with 2**31 - 1.

☕ Java Solution

public class Solution {
    public int reverse(int x) {
        // We'll use a long to safely store the reversed number
        long rev = 0;
        // Loop until x becomes 0
        while (x != 0) {
            // Get the last digit of x (e.g., 123 -> 3)
            rev = rev * 10 + x % 10;
            // Remove the last digit from x (e.g., 123 -> 12)
            x = x / 10;
        }
        // Check if reversed number is within 32-bit integer limits
        if (rev > Integer.MAX_VALUE || rev < Integer.MIN_VALUE) {
            return 0;
        }
        // Convert the long result back to int and return
        return (int) rev;
    }
}

✅ Explanation

• Use modulo % 10 to get last digit.
• Use division / 10 to remove last digit.
• Use a long for overflow check during the loop.

🌐 JavaScript Solution

var reverse = function(x) {
    // Check if number is negative
    let isNegative = x < 0;
    // Convert to positive, then to string, reverse it, and convert back to number
    let reversed = parseInt(Math.abs(x).toString().split('').reverse().join(''));
    // If reversed number exceeds the 32-bit max value, return 0
    if (reversed > 0x7FFFFFFF) return 0;
    // Return negative reversed number if input was negative
    return isNegative ? -reversed : reversed;
};

✅ Explanation

• Convert to string, reverse with split().reverse().join().
• Use parseInt to convert back.
• Check against max 32-bit integer (0x7FFFFFFF).

🧠 Key Learnings

• Understand 32-bit integer overflow boundaries.
• Always check for overflow after operations.
• Use built-in methods (like strrev, slicing, or string reversal) smartly.
• Optimize for time (O(log N)) and space (O(1) if done numerically).

🏁 Final Thoughts

The Reverse Integer problem may seem simple at first, but it teaches you defensive programming, bit manipulation awareness, and working with edge cases.

This question is a great warm-up for more advanced number manipulation problems like Palindrome Numbers, Integer to Roman, or String to Integer.

🧩 Two Sum — Explained simply

🚀 Difficulty: Easy | 💼 Asked in Many Interviews

📘 The Problem (from LeetCode)

Given an array of integers nums and an integer target, return the indices of the two numbers such that they add up to target.

You must:

• Return exactly one solution (you can assume there is always one)
• Not use the same element twice
• Return the indexes (positions) of the numbers, not the numbers themselves
• The order of the result doesn’t matter

💡 Let’s Understand With an Example:

nums = [2, 7, 11, 15]
target = 9

We need to find two numbers from the array whose sum is 9.

Let’s try:

• 2 + 7 = ✅ 9 → Found at index 0 and 1

Answer: [0, 1]

🎓 Real-Life Analogy:

Imagine you’re shopping. Your friend gives you ₹9 and a list of item prices. You need to pick 2 items that exactly total ₹9.

Item prices = [2, 7, 11, 15]
You pick ₹2 (item at index 0) and ₹7 (index 1). That’s the answer → [0, 1].

❗ Common Misunderstanding

Some people only check each element and the next one (i and i+1). But what if the answer is in some other pair (like index 1 and 3)? That logic will miss some valid answers.

We need to try every pair, not just adjacent ones.

🧐 Solution 1: Brute Force (Beginner Friendly)

Try every possible pair of numbers. If their sum is the target, return their indexes.

🧮 Logic:

• Loop over each number with index i
• Inside that loop, loop over every number after i (index j)
• Check if nums[i] + nums[j] == target
• If yes, return [i, j]

🕐 Time Complexity:

• O(n^2) (nested loops)

🧠 Pseudocode:

Loop i from 0 to length-1
    Loop j from i+1 to length
        if nums[i] + nums[j] == target
            return [i, j]

💻 PHP Code (With Comments)

class Solution {
    function twoSum($nums, $target) {
        $n = count($nums); // Get the size of the array
        for ($i = 0; $i < $n; $i++) {
            for ($j = $i + 1; $j < $n; $j++) {
                // Check if this pair sums up to the target
                if ($nums[$i] + $nums[$j] == $target) {
                    return [$i, $j]; // Return their positions
                }
            }
        }
        return []; // Return empty if no pair found
    }
}

☕ Java Code

class Solution {
    public int[] twoSum(int[] nums, int target) {
        int n = nums.length;
        for (int i = 0; i < n; i++) {
            for (int j = i + 1; j < n; j++) {
                if (nums[i] + nums[j] == target) {
                    return new int[] { i, j };
                }
            }
        }
        return new int[] {};
    }
}

🐍 Python Code

class Solution:
    def twoSum(self, nums, target):
        n = len(nums)
        for i in range(n):
            for j in range(i + 1, n):
                if nums[i] + nums[j] == target:
                    return [i, j]
        return []

🌐 JavaScript Code

function twoSum(nums, target) {
    for (let i = 0; i < nums.length; i++) {
        for (let j = i + 1; j < nums.length; j++) {
            if (nums[i] + nums[j] === target) {
                return [i, j];
            }
        }
    }
    return [];
}

💡 Solution 2: Optimized Using Hash Map (For Faster Performance)

Instead of checking every pair, we can:

• Use a hash map to remember numbers we’ve already seen
• For each number, check if target - current number already exists in the map

✅ Time: O(n), Space: O(n)

Python (Optimized):

class Solution:
    def twoSum(self, nums, target):
        seen = {}
        for i, num in enumerate(nums):
            complement = target - num
            if complement in seen:
                return [seen[complement], i]
            seen[num] = i

📒 Final Tips

• Master brute force first → it’s simple and helps understand the problem.
• Later, try to learn the hash map method — it’s fast and often asked in interviews.
• Practice writing in multiple languages (like we just did!) — great for polyglot devs.