Count of sub-strings of length n possible from the given string
Given a string str and an integer N, the task is to find the number of possible sub-strings of length N.
Examples:
Input: str = "geeksforgeeks", n = 5
Output: 9
All possible sub-strings of length 5 are "geeks", "eeksf", "eksfo",
"ksfor", "sforg", "forge", "orgee", "rgeek" and "geeks".
Input: str = "jgec", N = 2
Output: 3
Method 1:Naive Approach
Approach:
The approach used in this code is to iterate over all possible starting positions of a substring of length N in the given string str, and count the number of valid substrings. We can check if a substring is valid by using the substr function to extract a substring of length N starting from the current position, and checking if its length is equal to N.
Implementation:
#include <bits/stdc++.h>
using namespace std;
int count_substrings(string str, int n) {
int count = 0;
for (int i = 0; i <= str.length() - n; i++) {
string substring = str.substr(i, n);
// check if the current substring has length n
if (substring.length() == n) {
count++;
}
}
return count;
}
int main() {
string str = "geeksforgeeks";
int n = 5;
cout << count_substrings(str, n) << endl;
return 0;
}
public class CountSubstrings {
public static int countSubstrings(String str, int n) {
int count = 0;
for (int i = 0; i <= str.length() - n; i++) {
String substring = str.substring(i, i + n);
// check if the current substring has length n
if (substring.length() == n) {
count++;
}
}
return count;
}
public static void main(String[] args) {
String str = "geeksforgeeks";
int n = 5;
System.out.println(countSubstrings(str, n));
}
}
def count_substrings(string, n):
count = 0
for i in range(len(string) - n + 1):
substring = string[i:i+n]
# check if the current substring has length n
if len(substring) == n:
count += 1
return count
str = "geeksforgeeks"
n = 5
print(count_substrings(str, n))
using System;
class GFG
{
// Function to count the number of substrings of length n in a given string.
static int CountSubstrings(string str, int n)
{
int count = 0;
// Loop through the string starting from index 0 and going up to length - n.
for (int i = 0; i <= str.Length - n; i++)
{
// Get the substring of length n starting at index i.
string substring = str.Substring(i, n);
// Check if the current substring has length n.
if (substring.Length == n)
{
count++;
}
}
return count;
}
static void Main()
{
string str = "geeksforgeeks";
int n = 5;
// Call the function to count substrings and print the result.
Console.WriteLine(CountSubstrings(str, n));
}
}
//Javascript Code
function count_substrings(str, n) {
let count = 0;
for (let i = 0; i <= str.length - n; i++) {
let substring = str.substr(i, n);
// check if the current substring has length n
if (substring.length === n) {
count++;
}
}
return count;
}
//Driver's Code
let str = "geeksforgeeks";
let n = 5;
console.log(count_substrings(str, n));
Output
9
Time Complexity: O(M*N), where M is the length of the input string str, since we iterate over N possible starting positions and extract a substring of length N each time.
Auxiliary Space: O(1), no extra space is required.
Method 2:Efficient Approach
Approach: The count of sub-strings of length n will always be len - n + 1 where len is the length of the given string. For example, if str = "geeksforgeeks" and n = 5 then the count of sub-strings having length 5 will be "geeks", "eeksf", "eksfo", "ksfor", "sforg", "forge", "orgee", "rgeek" and "geeks" which is len - n + 1 = 13 - 5 + 1 = 9.
Below is the implementation of the above approach:
// C++ implementation of the approach
#include <bits/stdc++.h>
using namespace std;
// Function to return the count of
// possible sub-strings of length n
int countSubStr(string str, int n)
{
int len = str.length();
return (len - n + 1);
}
// Driver code
int main()
{
string str = "geeksforgeeks";
int n = 5;
cout << countSubStr(str, n);
return 0;
}
// Java implementation of the approach
import java.util.*;
class GFG
{
// Function to return the count of
// possible sub-strings of length n
static int countSubStr(String str, int n)
{
int len = str.length();
return (len - n + 1);
}
// Driver code
public static void main(String args[])
{
String str = "geeksforgeeks";
int n = 5;
System.out.print(countSubStr(str, n));
}
}
// This code is contributed by mohit kumar 29
# Python3 implementation of the approach
# Function to return the count of
# possible sub-strings of length n
def countSubStr(string, n) :
length = len(string);
return (length - n + 1);
# Driver code
if __name__ == "__main__" :
string = "geeksforgeeks";
n = 5;
print(countSubStr(string, n));
# This code is contributed by Ryuga
// C# implementation of the approach
using System;
class GFG
{
// Function to return the count of
// possible sub-strings of length n
static int countSubStr(string str, int n)
{
int len = str.Length;
return (len - n + 1);
}
// Driver code
public static void Main()
{
string str = "geeksforgeeks";
int n = 5;
Console.WriteLine(countSubStr(str, n));
}
}
// This code is contributed by Code_Mech.
<script>
// JavaScript implementation of the approach
// Function to return the count of
// possible sub-strings of length n
function countSubStr(str, n) {
var len = str.length;
return len - n + 1;
}
// Driver code
var str = "geeksforgeeks";
var n = 5;
document.write(countSubStr(str, n));
</script>
<?php
// PHP implementation of the approach
// Function to return the count of
// possible sub-strings of length n
function countSubStr($str, $n)
{
$len = strlen($str);
return ($len - $n + 1);
}
// Driver code
$str = "geeksforgeeks";
$n = 5;
echo(countSubStr($str, $n));
// This code is contributed by Code_Mech.
?>
Output
9
Time Complexity: O(1), it is a constant.
Auxiliary Space: O(1), no extra space is required.
