# 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 = 47Output:2 Only the sub-strings "471" and "71" satisfy the given conditions.Input:S = "2222", X = 97Output: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 integer.
- Compare the integer from 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; ` `} ` |

*chevron_right*

*filter_none*

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

*chevron_right*

*filter_none*

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

*chevron_right*

*filter_none*

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

*chevron_right*

*filter_none*

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

*chevron_right*

*filter_none*

**Output:**

3

## Recommended Posts:

- Count of substrings whose Decimal equivalent is greater than or equal to K
- Count Substrings with equal number of 0s, 1s and 2s
- Number of substrings with count of each character as k
- Count number of distinct substrings of a given length
- Count number of substrings with exactly k distinct characters
- Count the number of vowels occurring in all the substrings of given string
- Given a binary string, count number of substrings that start and end with 1.
- Count number of substrings of a string consisting of same characters
- Count the number of words having sum of ASCII values less than and greater than k
- Count numbers with difference between number and its digit sum greater than specific value
- Count number of binary strings such that there is no substring of length greater than or equal to 3 with all 1's
- Count all substrings having character K
- Count substrings that contain all vowels | SET 2
- Count substrings with same first and last characters
- Count Uppercase, Lowercase, special character and numeric values
- Count of substrings which contains a given character K times
- Count of substrings of a binary string containing K ones
- Count of substrings consisting only of vowels
- Count of total anagram substrings
- Count distinct substrings that contain some characters at most k times

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.