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
Complexity Analysis:
- Time Complexity: O(N3)
- Auxiliary Space: O(1)