 GFG App
Open App Browser
Continue

# 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!

My Personal Notes arrow_drop_up