Skip to content
Related Articles

Related Articles

Save Article
Improve Article
Save Article
Like Article

Count number of substrings with numeric value greater than X

  • Difficulty Level : Basic
  • Last Updated : 25 May, 2021

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++




// 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




// 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




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




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

Javascript




<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>
Output: 
3

 




My Personal Notes arrow_drop_up
Recommended Articles
Page :