JavaScript Program to Find Longest Common Substring Between Two Strings

Last Updated : 21 May, 2024

In this article, we will see how to find the longest common substring between two strings in JavaScript.

A substring is a contiguous sequence of characters within a string. It can be obtained by extracting part of the string starting from any position. We are going to write a JavaScript function that will take two strings and find the common longest consecutive string.

There are two approaches to finding the longest common substring between two strings

Table of Content

Brute-force approach
Dynamic Programming
Using indexOf() and Recursion

Brute-force approach

In this method, we create all possible substrings from both strings and compare them to determine which substring has the longest length in common. The findLongestCommonSubstring() function uses nested loops to generate all possible substrings and compares them to find the longest common substring. In this example, the function findLongestCommonSubstring returns the longest common substring between any two input strings (str1 and str2) given two input strings. In this method time complexity is O(n*m), where n and m are the lengths of the input strings.

Example:

JavaScript

function findLongestCommonSubstring(str1, str2) {
    let longestSubstring = "";

    for (let i = 0; i < str1.length; i++) {
        for (let j = 0; j < str2.length; j++) {
            let substring = "";
            let x = i;
            let y = j;

            while (x < str1.length && 
                   y < str2.length && 
                   str1[x] === str2[y]) {
                substring += str1[x];
                x++;
                y++;
            }

            if (substring.length > longestSubstring.length) {
                longestSubstring = substring;
            }
        }
    }

    return longestSubstring;
}

const string1 = "GeeksForgeeks";
const string2 = "Geekscode";

const longestCommonSubstring = 
      findLongestCommonSubstring(string1, string2);
      
console.log("Longest Common Substring:", 
    longestCommonSubstring);

Output

Longest Common Substring: Geeks

Dynamic Programming

The dynamic programming is the optimised approach of the previous method. In this method we will use 2D array for storing the lengths of common substrings between str1 and str2. In this example, we are creating an LCS table to store the length of the longest common substring ending at that position. After filling the table by iterating through both strings and incrementing the value if the characters match. Then we keep track of the maximum length seen and the corresponding substring and return the longest substring found.

Example:

JavaScript

function longestCommonSubstring(str1, str2) {
    let n = str1.length;
    let m = str2.length;

    let lcs = [];
    for (let i = 0; i <= n; i++) {
        lcs[i] = [];
        for (let j = 0; j <= m; j++) {
            lcs[i][j] = 0;
        }
    }

    let result = "";
    let max = 0;
    for (let i = 0; i < n; i++) {
        for (let j = 0; j < m; j++) {
            if (str1[i] === str2[j]) {
                lcs[i + 1][j + 1] = lcs[i][j] + 1;
                if (lcs[i + 1][j + 1] > max) {
                    max = lcs[i + 1][j + 1];
                    result = str1.substring(i - max + 1, i + 1);
                }
            }
        }
    }

    return result;
}

let str1 = "GeeksForgeeks";
let str2 = "Geekscode";

let result = longestCommonSubstring(str1, str2);

console.log("Longest Common Substring:", result);

Output

Longest Common Substring: Geeks

Using indexOf() and Recursion

To find the longest common substring using indexOf() and recursion, recursively remove characters from the end of each string until a common substring is found. This approach efficiently handles large inputs with overlapping substrings.

Example: In this example the longestCommonSubstring function uses dynamic programming to find the longest common substring between str1 and str2. It returns the identified substring.

JavaScript

function longestCommonSubstring(str1, str2) {
    const matrix = Array.from({ length: str1.length + 1 }, () => Array.from({
        length: str2.length + 1
    }, () => 0));
    let longestLength = 0;
    let endIndex = 0;

    for (let i = 1; i <= str1.length; i++) {
        for (let j = 1; j <= str2.length; j++) {
            if (str1[i - 1] === str2[j - 1]) {
                matrix[i][j] = matrix[i - 1][j - 1] + 1;
                if (matrix[i][j] > longestLength) {
                    longestLength = matrix[i][j];
                    endIndex = i;
                }
            }
        }
    }

    return str1.slice(endIndex - longestLength, endIndex);
}

const string1 = "abcdef";
const string2 = "bcde";
console.log(longestCommonSubstring(string1, string2));

Output

bcde

JavaScript Program to Find the Length of Longest Balanced Subsequence

pranay0911

Improve

Article Tags :

JavaScript Program to Find Longest Common Substring Between Two Strings

Brute-force approach

Dynamic Programming

Using indexOf() and Recursion

Similar Reads

Thank You!

What kind of Experience do you want to share?