Count number of substrings with numeric value greater than X

Given a string 'S' (composed of digits) and an integer 'X", the task is to count all the sub-strings of 'S' that satisfy the following conditions:  

• The sub-string must not begin with the digit '0'.
• And the numeric number it represents must be greater than 'X'.

Note: Two ways of selecting a sub-string are different if they begin or end at different indices.

Examples:  

Input: S = "471", X = 47
Output: 2
Only the sub-strings "471" and "71" 
satisfy the given conditions.

Input: S = "2222", X = 97
Output: 3
Valid strings are "222", "222" and "2222". 

Approach:  

• Iterate over each digit of the string 'S' and choose the digits which are greater than '0'.
• Now, take all possible sub-strings starting from the character chosen in the previous step and convert each sub-string to an integer.
• Compare the integer from the previous step to 'X'. If the number is greater than 'X', then increment the count variable.
• Finally, print the value of the count variable.

Below is the implementation of the above approach:  

// C++ implementation of the approach
#include <bits/stdc++.h>
using namespace std;

// Function that counts
// valid sub-strings
int count(string S, int X)
{
    int count = 0;
    const int N = S.length();
    for (int i = 0; i < N; ++i) {

        // Only take those numbers
        // that do not start with '0'.
        if (S[i] != '0') {
            for (int len = 1; (i + len) <= N; ++len) {

                // converting the sub-string
                // starting from index 'i'
                // and having length 'len' to int
                // and checking if it is greater
                // than X or not
                if (stoi(S.substr(i, len)) > X)
                    count++;
            }
        }
    }
    return count;
}

// Driver code
int main()
{

    string S = "2222";
    int X = 97;
    cout << count(S, X);

    return 0;
}

// Java implementation of the approach
import java.util.*;

class GFG
{
// Function that counts
// valid sub-strings
static int count(String S, int X)
{
    int count = 0;
    int N = S.length();
    for (int i = 0; i < N; ++i)
    {

        // Only take those numbers
        // that do not start with '0'.
        if (S.charAt(i) != '0')
        {
            for (int len = 1; 
                (i + len) <= N; ++len) 
            {

                // converting the sub-string
                // starting from index 'i'
                // and having length 'len' to 
                // int and checking if it is 
                // greater than X or not
                int num = Integer.parseInt(S.substring(i, i + len));
                if (num > X)
                    count++;
            }
        }
    }
    return count;
}

// Driver code
public static void main(String []args)
{
    String S = "2222";
    int X = 97;
    System.out.println(count(S, X));
}
}

// This code is contributed by ihritik

# Python3 implementation of
# the approach

# Function that counts
# valid sub-strings
def countSubStr(S, X):

    cnt = 0
    N = len(S)
    
    for i in range(0, N):

        # Only take those numbers
        # that do not start with '0'.
        if (S[i] != '0'):
            
            j = 1
            while((j + i) <= N):

                # converting the sub-string
                # starting from index 'i'
                # and having length 'len' to 
                # int and checking if it is 
                # greater than X or not
                num = int(S[i : i + j])
            
                if (num > X):
                    cnt = cnt + 1
                
                j = j + 1
        
    return cnt;

# Driver code
S = "2222";
X = 97;
print(countSubStr(S, X))

# This code is contributed by ihritik

// C# implementation of the approach
using System;

class GFG
{
// Function that counts
// valid sub-strings
static int count(string S, int X)
{
    int count = 0;
    int N = S.Length;
    for (int i = 0; i < N; ++i) 
    {

        // Only take those numbers
        // that do not start with '0'.
        if (S[i] != '0') 
        {
            for (int len = 1; 
                (i + len) <= N; ++len) 
            {

                // converting the sub-string
                // starting from index 'i'
                // and having length 'len' to int
                // and checking if it is greater
                // than X or not
                int num = Int32.Parse(S.Substring(i, len));
                if (num > X)
                    count++;
            }
        }
    }
    return count;
}

// Driver code
public static void Main(String []args)
{
    string S = "2222";
    int X = 97;
    Console.WriteLine(count(S, X));
}
}

// This code is contributed by ihritik

<?php
// PHP implementation of the approach

// Function that counts
// valid sub-strings
function countSubStr($S, $X)
{
    $cnt = 0;
    $N = strlen($S);
    
    for ($i = 0; $i < $N; ++$i) 
    {

        // Only take those numbers
        // that do not start w$ith '0'.
        if ($S[$i] != '0') 
        {
            for ($len = 1; 
                ($i + $len) <= $N; ++$len) 
            {

                // converting the sub-str$ing
                // starting from index 'i'
                // and having length 'len' to int
                // and checking if it is greater
                // than X or not
                $num = intval(substr($S, $i, $len));
            
                if ($num > $X)
                    $cnt++;
            }
        }
    }
    return $cnt;
}

// Driver code
$S = "2222";
$X = 97;
echo countSubStr($S, $X);

// This code is contributed by ihritik
?>

<script>

// Javascript implementation of the approach

// Function that counts
// valid sub-strings
function count(S, X)
{
    var count = 0;
    var N = S.length;
    for (var i = 0; i < N; ++i) {

        // Only take those numbers
        // that do not start with '0'.
        if (S[i] != '0') {
            for (var len = 1; (i + len) <= N; ++len) {

                // converting the sub-string
                // starting from index 'i'
                // and having length 'len' to int
                // and checking if it is greater
                // than X or not
                if (parseInt(S.substring(i, i+len)) > X)
                    count++;
            }
        }
    }
    return count;
}

// Driver code
var S = "2222";
var X = 97;
document.write( count(S, X));

</script> 

3

Complexity Analysis:

• Time Complexity: O(N³)
• Auxiliary Space: O(1)