Python Program To Find Longest Common Prefix Using Word By Word Matching
Last Updated :
19 Mar, 2023
Given a set of strings, find the longest common prefix.
Examples:
Input : {“geeksforgeeks”, “geeks”, “geek”, “geezer”}
Output : "gee"
Input : {"apple", "ape", "april"}
Output : "ap"
We start with an example. Suppose there are two strings- “geeksforgeeks” and “geeks”. What is the longest common prefix in both of them? It is “geeks”.
Now let us introduce another word “geek”. So now what is the longest common prefix in these three words ? It is “geek”
We can see that the longest common prefix holds the associative property, i.e-
LCP(string1, string2, string3)
= LCP (LCP (string1, string2), string3)
Like here
LCP (“geeksforgeeks”, “geeks”, “geek”)
= LCP (LCP (“geeksforgeeks”, “geeks”), “geek”)
= LCP (“geeks”, “geek”) = “geek”
So we can make use of the above associative property to find the LCP of the given strings. We one by one calculate the LCP of each of the given string with the LCP so far. The final result will be our longest common prefix of all the strings.
Note that it is possible that the given strings have no common prefix. This happens when the first character of all the strings are not same.
We show the algorithm with the input strings- “geeksforgeeks”, “geeks”, “geek”, “geezer” by the below figure.

Below is the implementation of above approach:
Python3
def commonPrefixUtil(str1, str2):
result = "";
n1 = len (str1)
n2 = len (str2)
i = 0
j = 0
while i < = n1 - 1 and j < = n2 - 1 :
if (str1[i] ! = str2[j]):
break
result + = str1[i]
i + = 1
j + = 1
return (result)
def commonPrefix (arr, n):
prefix = arr[ 0 ]
for i in range ( 1 , n):
prefix = commonPrefixUtil(prefix,
arr[i])
return (prefix)
if __name__ = = "__main__" :
arr = [ "geeksforgeeks" , "geeks" ,
"geek" , "geezer" ]
n = len (arr)
ans = commonPrefix(arr, n)
if ( len (ans)):
print ( "The longest common prefix is -" ,
ans);
else :
print ( "There is no common prefix" )
|
Output
The longest common prefix is - gee
Time Complexity : Since we are iterating through all the strings and for each string we are iterating though each characters, so we can say that the time complexity is O(N M) where,
N = Number of strings
M = Length of the largest string string
Auxiliary Space : To store the longest prefix string we are allocating space which is O(M). Please refer complete article on Longest Common Prefix using Word by Word Matching for more details!
Method #2:
In this approach, the first word is taken as the longest common prefix, and then each subsequent word is compared to the prefix character by character. The prefix is updated as needed so that it only includes characters that are common to all the words. This process continues until all the words have been compared and the longest common prefix has been found.
Approach:
- Define the function find_longest_common_prefix that takes a list of words as input.
- Initialize the variable longest_common_prefix to the first word in the list of words.
- Loop through each word in the list of words, starting from the second word.
- Loop through each character in the current longest common prefix.
- If the current character is not the same as the character in the same position in the current word, update the longest_common_prefix variable to the substring of the longest common prefix up to the index of the current character and break out of the loop.
- If the loop completes without breaking, the longest_common_prefix variable will be equal to the shortest word in the list of words.
- Return the longest_common_prefix variable.
Python3
def find_longest_common_prefix(words):
longest_common_prefix = words[ 0 ]
for word in words[ 1 :]:
for i in range ( len (longest_common_prefix)):
if i > = len (word) or longest_common_prefix[i] ! = word[i]:
longest_common_prefix = longest_common_prefix[:i]
break
return longest_common_prefix
words = [ "geeksforgeeks" , "geeks" , "geek" , "geezer" ]
longest_common_prefix = find_longest_common_prefix(words)
print ( "The longest common prefix is:" , longest_common_prefix)
|
Output
The longest common prefix is: gee
Overall, the function has a time complexity of O(mn)
Auxiliary space: O(1), where m is the length of the longest word and n is the number of words in the list.
Similar Reads
Python Program To Find Longest Common Prefix Using Sorting
Problem Statement: Given a set of strings, find the longest common prefix.Examples: Input: {"geeksforgeeks", "geeks", "geek", "geezer"} Output: "gee" Input: {"apple", "ape", "april"} Output: "ap" The longest common prefix for an array of strings is the common prefix between 2 most dissimilar strings
2 min read
Python program to find the longest word in a sentence
In this article, we will explore various methods to find the longest word in a sentence. Using LoopFirst split the sentence into words using split() and then uses a loop (for loop) to iterate through the words and keeps track of the longest word by comparing their lengths. [GFGTABS] Python s =
1 min read
Python Program to Return the Length of the Longest Word from the List of Words
When working with lists of words in Python, we may need to determine the length of the longest word in the list. For example, given a list like ["Python", "with", "GFG], we would want to find that "Python" has the longest length. Let's go through some methods to achieve this. Using max() max() funct
3 min read
Python Program for Longest Common Subsequence
LCS Problem Statement: Given two sequences, find the length of longest subsequence present in both of them. A subsequence is a sequence that appears in the same relative order, but not necessarily contiguous. For example, "abc", "abg", "bdf", "aeg", '"acefg", .. etc are subsequences of "abcdefg". So
3 min read
Python - Ways to determine common prefix in set of strings
A common prefix is the longest substring that appears at the beginning of all strings in a set. Common prefixes in a set of strings can be determined using methods like os.path.commonprefix() for quick results, itertools.takewhile() combined with zip() for a more flexible approach, or iterative comp
2 min read
Python Program to find the Larger String without Using Built-in Functions
Given two strings. The task is to find the larger string without using built-in functions. Examples: Input: GeeksforGeeks Geeks Output: GeeksforGeeks Input: GeeksForFeeks is an good Computer Coding Website It offers several topics Output: GeeksForFeeks is an good Computer Coding Website Step-by-step
3 min read
Python Program to print strings based on the list of prefix
Given a Strings List, the task here is to write a python program that can extract all the strings whose prefixes match any one of the custom prefixes given in another list. Input : test_list = ["geeks", "peeks", "meeks", "leeks", "mean"], pref_list = ["ge", "ne", "me", "re"] Output : ['geeks', 'meek
5 min read
Python Program To Find Length Of The Longest Substring Without Repeating Characters
Given a string str, find the length of the longest substring without repeating characters. For âABDEFGABEFâ, the longest substring are âBDEFGAâ and "DEFGAB", with length 6.For âBBBBâ the longest substring is âBâ, with length 1.For "GEEKSFORGEEKS", there are two longest substrings shown in the below
6 min read
Python program to find the character position of Kth word from a list of strings
Given a list of strings. The task is to find the index of the character position for the word, which lies at the Kth index in the list of strings. Examples: Input : test_list = ["geekforgeeks", "is", "best", "for", "geeks"], K = 21 Output : 0Explanation : 21st index occurs in "geeks" and point to "g
3 min read
Python Program To Get Minimum Elements For String Construction
Given a String, the task is to write a Python program to count the minimum elements required to form a string from list elements. Input : test_list = ["geek", "ring", "sfor", "ok", "woke"], tar_str = "working" Output : 2 Explanation : working can be formed using woke and ring. Input : test_list = ["
3 min read