Java Program To Check If A String Is Substring Of Another
Given two strings s1 and s2, find if s1 is a substring of s2. If yes, return the index of the first occurrence, else return -1.
Examples :
Input: s1 = "for", s2 = "geeksforgeeks" Output: 5 Explanation: String "for" is present as a substring of s2. Input: s1 = "practice", s2 = "geeksforgeeks" Output: -1. Explanation: There is no occurrence of "practice" in "geeksforgeeks"
Simple Approach: The idea is to run a loop from start to end and for every index in the given string check whether the sub-string can be formed from that index. This can be done by running a nested loop traversing the given string and in that loop run another loop checking for sub-string from every index.
For example, consider there to be a string of length N and a substring of length M. Then run a nested loop, where the outer loop runs from 0 to (N-M) and the inner loop from 0 to M. For very index check if the sub-string traversed by the inner loop is the given sub-string or not.
Java
// Java program to check if a string is // substring of other. class GFG { // Returns true if s1 is substring of s2 static int isSubstring( String s1, String s2) { int M = s1.length(); int N = s2.length(); // A loop to slide pat[] one by one for (int i = 0; i <= N - M; i++) { int j; /* For current index i, check for pattern match */ for (j = 0; j < M; j++) if (s2.charAt(i + j) != s1.charAt(j)) break; if (j == M) return i; } return -1; } // Driver code public static void main(String args[]) { String s1 = "for"; String s2 = "geeksforgeeks"; int res = isSubstring(s1, s2); if (res == -1) System.out.println("Not present"); else System.out.println( "Present at index " + res); } } // This code is contributed by JaideepPyne. |
Output:
Present at index 5
Complexity Analysis:
- Time complexity: O(m * n) where m and n are lengths of s1 and s2 respectively.
A nested loop is used the outer loop runs from 0 to N-M and inner loop from 0 to M so the complexity is O(m*n). - Space Complexity: O(1).
As no extra space is required.
An efficient solution is to use a O(n) searching algorithm like KMP algorithm, Z algorithm, etc.
Language implementations:
Another Efficient Solution:
- An efficient solution would need only one traversal i.e. O(n) on the longer string s1. Here we will start traversing the string s1 and maintain a pointer for string s2 from 0th index.
- For each iteration we compare the current character in s1 and check it with the pointer at s2.
- If they match we increment the pointer on s2 by 1. And for every mismatch we set the pointer back to 0.
- Also keep a check when the s2 pointer value is equal to the length of string s2, if true we break and return the value (pointer of string s1 – pointer of string s2)
- Works with strings containing duplicate characters.
Java
// Java program to implement // the above approach import java.io.*; class GFG { public static int Substr(String s2, String s1) { // pointing s2 int counter = 0; int i = 0; for(; i < s1.length(); i++) { if(counter == s2.length()) break; if(s2.charAt(counter) == s1.charAt(i)) { counter++; } else { // Special case where character preceding // the i'th character is duplicate if(counter > 0) { i -= counter; } counter = 0; } } return (counter < s2.length() ? -1 : i - counter); } // Driver code public static void main (String[] args) { String s1 = "geeksfffffoorrfoorforgeeks"; System.out.println(Substr("for", s1)); } } |
Output:
18
Complexity Analysis:
The complexity of the above code will be still O(n*m) in the worst case and the space complexity is O(1).
Please refer complete article on Check if a string is substring of another for more details!
Please Login to comment...