 GeeksforGeeks App
Open App Browser
Continue

# Print all Substrings of length n possible from the given String

Given a string str and an integer N, the task is to print all possible sub-strings of length N.

Examples:

Input: str = “geeksforgeeks”, N = 3
Output: gee eek eks ksf sfo for org rge gee eek eks
Explanations: All possible sub-strings of length 3 are “gee”, “eek”, “eks”, “ksf”, “sfo”, “for”, “org”, “rge”, “gee”, “eek” and “eks”.

Input: str = “GFG”, N = 2
Output: GF FG
Explanations: All possible sub-strings of length 2 are “GF”, “FG”

### Method 1: Using slicing

Approach: To solve the problem follow the below steps:

• Initialize a variable ‘n’ to the desired length of the substrings.
• Use a for loop to iterate through the characters of the original string, starting from the first character.
• In each iteration of the loop, use slicing to extract a substring of length ‘n’ from the original string, starting from the current character. The slicing can be done by using the syntax ‘string[start:end]’ where the start and end are the indices of the first and last character of the substring, respectively.
• In each iteration, the variable ‘i’ will be the starting index of the substring, and ‘i + n’ will be the ending index of the substring, so the substring can be extracted by using the slicing syntax ‘string[i: i + n]’.
• Print or store the extracted substring for further processing.
• Repeat the process for all characters in the original string.

Below is the implementation of the above approach:

## C++

 `// CPP implementation of the approach``#include ``#include ``using` `namespace` `std;` `// Drivers code``int` `main()``{``    ``string str = ``"geeksforgeeks"``;``    ``int` `n = 3;``    ``for` `(``int` `i = 0; i < str.length() - n + 1; i++)``        ``cout << str.substr(i, n) << ``" "``;``    ``return` `0;``}`

## Java

 `// Java implementation of the approach``import` `java.util.*;` `class` `GFG {``    ``public` `static` `void` `main(String args[])``    ``{``        ``String str = ``"geeksforgeeks"``;``        ``int` `n = ``3``;``        ``for` `(``int` `i = ``0``; i < str.length() - n + ``1``; i++)``            ``System.out.print(str.substring(i, i + n) + ``" "``);``    ``}``}``// This code is contributed by Susobhan Akhuli`

## Python3

 `# Python implementation of the approach``str` `=` `"geeksforgeeks"``n ``=` `3` `for` `i ``in` `range``(``len``(``str``) ``-` `n ``+` `1``):``    ``print``(``str``[i:i ``+` `n], end ``=` `" "``)` `# This code is contributed by Susobhan Akhuli`

## C#

 `// C# implementation of the approach``using` `System;` `class` `MainClass {``    ``public` `static` `void` `Main(``string``[] args)``    ``{``        ``string` `str = ``"geeksforgeeks"``;``        ``int` `n = 3;``        ``for` `(``int` `i = 0; i < str.Length - n + 1; i++)``            ``Console.Write(str.Substring(i, n) + ``" "``);``    ``}``}` `// This code is contributed by Susobhan Akhuli`

## Javascript

 ``

Output

`gee eek eks ksf sfo for org rge gee eek eks `

Time Complexity: O(|str|*n), where |str| is the length of the string
Auxiliary Space: O(n)

### Method 2: Using a for loop

Approach: To solve the problem follow the below steps:

• Initialize a variable ‘n‘ to the desired length of the substrings.
• Use a for loop to iterate through the characters of the original string, starting from the first character.
• In each iteration of the outer loop, initialize an empty variable ‘substring‘ to store the extracted substring.
• Use a nested for loop to iterate through the next ‘n’ characters of the original string, starting from the current character.
• In each iteration of the inner loop, add the current character to the ‘substring’ variable.
• After the inner loop finishes, print or store the extracted substring for further processing.
• Repeat the process for all characters in the original string.

Below is the implementation of the above approach:

## C++

 `// CPP implementation of the approach``#include ``#include ``using` `namespace` `std;` `int` `main()``{``    ``string str = ``"geeksforgeeks"``;``    ``int` `n = 3;``    ``for` `(``int` `i = 0; i < str.length() - n + 1; i++) {``        ``string substring = ``""``;``        ``for` `(``int` `j = i; j < i + n; j++)``            ``substring += str[j];``        ``cout << substring << ``" "``;``    ``}``    ``return` `0;``}``// This code is contributed by Susobhan Akhuli`

## Java

 `// Java implementation of the approach``import` `java.util.*;` `public` `class` `GFG {``    ``public` `static` `void` `main(String[] args)``    ``{``        ``String str = ``"geeksforgeeks"``;``        ``int` `n = ``3``;``        ``for` `(``int` `i = ``0``; i < str.length() - n + ``1``; i++) {``            ``String substring = ``""``;``            ``for` `(``int` `j = i; j < i + n; j++)``                ``substring += str.charAt(j);``            ``System.out.print(substring + ``" "``);``        ``}``    ``}``}` `// This code is contributed by Susobhan Akhuli`

## Python3

 `# Python implementation of the approach``str` `=` `"geeksforgeeks"``n ``=` `3` `for` `i ``in` `range``(``len``(``str``) ``-` `n ``+` `1``):``    ``substring ``=` `""``    ``for` `j ``in` `range``(i, i ``+` `n):``        ``substring ``+``=` `str``[j]``    ``print``(substring, end ``=``' '``)` `# This code is contributed by Susobhan Akhuli`

## C#

 `// C# implementation of the approach``using` `System;` `class` `Program {``    ``static` `void` `Main(``string``[] args)``    ``{``        ``string` `str = ``"geeksforgeeks"``;``        ``int` `n = 3;``        ``for` `(``int` `i = 0; i < str.Length - n + 1; i++) {``            ``string` `substring = ``""``;``            ``for` `(``int` `j = i; j < i + n; j++)``                ``substring += str[j];``            ``Console.Write(substring + ``" "``);``        ``}``    ``}``}` `// This code is contributed by Susobhan Akhuli`

## Javascript

 ``

Output

`gee eek eks ksf sfo for org rge gee eek eks `

Time Complexity: O(|str|*n), where |str| is the length of the string
Auxiliary Space: O(n)

### Method 3: Using list comprehension (Only for Python)

Approach: To solve the problem follow the below steps:

• Initialize a variable ‘n’ to the desired length of the substrings.
• Use a list comprehension to iterate through the characters of the original string and extract substrings of length ‘n’ in one line.
• The list comprehension uses the slicing syntax ‘string[start:end]’ where the start and end are the indices of the first and last character of the substring, respectively.
• The variable ‘i’ will be the starting index of the substring and ‘i+n’ will be the ending index of the substring, so the substring can be extracted by using the slicing syntax ‘string[i:i+n]’ inside the list comprehension.
• Assign the output of the list comprehension to a variable e.g. substrings = [string[i:i+n] for i in range(len(string) – n + 1)]
• Then you can print or access individual substrings from the list by indexing.

Below is the implementation of the above approach:

## C++

 `#include ``#include ``using` `namespace` `std;` `int` `main() {``    ``// C++ implementation of the approach``    ``string str = ``"geeksforgeeks"``;``    ``int` `n = 3;``    ``vector substrings;` `    ``for` `(``int` `i = 0; i <= str.length() - n; i++) {``        ``substrings.push_back(str.substr(i, n));``    ``}` `    ``for` `(``auto` `s : substrings) {``        ``cout << s << ``" "``;``    ``}``    ``cout << endl;` `    ``return` `0;``}`

## Java

 `/*package whatever //do not write package name here */` `import` `java.util.*;` `class` `GFG {``    ``public` `static` `void` `main (String[] args) {``//Java implementation of the approach``String str = ``"geeksforgeeks"``;``int` `n = ``3``;``List substrings = ``new` `ArrayList<>();` `for` `(``int` `i = ``0``; i <= str.length() - n; i++) {``    ``substrings.add(str.substring(i, i + n));``}` `System.out.println(substrings);    }``}`

## Python3

 `# Python implementation of the approach``str` `=` `"geeksforgeeks"``n ``=` `3``substrings ``=` `[``str``[i:i ``+` `n] ``for` `i ``in` `range``(``len``(``str``) ``-` `n ``+` `1``)]``print``(substrings)` `# This code is contributed by Susobhan Akhuli`

## Javascript

 `// JavaScript implementation of the approach``let str = ``"geeksforgeeks"``;``let n = 3;``let substrings = [];` `for` `(let i = 0; i <= str.length - n; i++) {``substrings.push(str.slice(i, i + n));``}` `console.log(substrings);` `// This code is contributed by codebraxnzt`

## C#

 `using` `System;``using` `System.Collections.Generic;` `class` `GFG {``    ``static` `void` `Main(``string``[] args) {``        ``// C# implementation of the approach``        ``string` `str = ``"geeksforgeeks"``;``        ``int` `n = 3;``        ``List<``string``> substrings = ``new` `List<``string``>();` `        ``for` `(``int` `i = 0; i <= str.Length - n; i++) {``            ``substrings.Add(str.Substring(i, n));``        ``}` `        ``Console.WriteLine(``string``.Join(``", "``, substrings));``    ``}``}`

Output

`['gee', 'eek', 'eks', 'ksf', 'sfo', 'for', 'org', 'rge', 'gee', 'eek', 'eks']`

Time Complexity: O(|str|*n), where |str| is the length of the string
Auxiliary Space: O(|str|*n)

N.B.: It is important to note that the above approach will only work if the length of the string is greater than n, otherwise it will throw index out of range error.

My Personal Notes arrow_drop_up