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));

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.
?>

9

Time Complexity: O(1), it is a constant.
Auxiliary Space: O(1), no extra space is required.