GFG App
Open App
Browser
Continue

Check if String S can be compressed to T by replacing some X characters with count X

Given two strings, S and T where S is a normal string and T is a compressed string, the task is to determine if the compressed string T can be achieved by compressing the string S

Note: A compression mechanism can arbitrarily delete X (X >= 0) characters and replace them with the deleted character count (X).

Examples:

Input: S = “HELLOWORLD”  T=”H2L4L1″
Output: True
Explanation:
Replace index 1 to 2 in “HELLOWORLD” with count 2 -> “H2LOWORLD”
Replace index 4 to 7 in “HELLOWORLD” with count 4 -> “H2L4LD”
Replace index 9 in “HELLOWORLD” with count 1 -> “H2L4L1
The resultant string is same as T. Hence String S can be compressed to T.

Input: S = “DFS”  T=”D1D”
Output: False
Explanation: We can clearly see that T is not a valid compressed string for S as compressed string T is ending with “D” which is not similar with the former string S.

Approach: The idea is to simply traverse the string and match the characters as follows:

• Compare the characters at corresponding indices in S and T,
• Similarly skip the count of indices in between two alphabets in T.

Illustration:

Consider S = “HELLOWORLD”  T=”H2L4L1″

In compressed string, 2 is the integer between ‘H’ and ‘L’,so string S must has any two characters between ‘H’ and ‘L’, and it has (HELLOWORLD).

Then next integer is 4 between ‘L’ and ‘L’, then check whether String S has 4 characters or not, (HELLOWORLD)

And last integer is 1 after character ‘L’ and String also has 1 character(i.e ‘D’) after ‘L’. (HELLOWORLD)

So, this Compressed String is valid.

S = “HELLOWORLD”  T=”H2L4L1

Follow the below steps to solve the problem:

• Start Traversing S and T string until its length simultaneously.
• Check whether T[i] is number or not, if it is not a number then compare S[j] and T[i] if they are not equal then directly return 0 else continue and increment j by 1 .
• If T[i] is a number then increase the j to that number until we get numbers in T string .
• Increment i by 1 until length of T.
• If j is not equal to S of length then return 0.
• If all conditions are satisfied then return 1 at last.

Below is the implementation of the above approach:

C++

 // C++ code for the above approach:   #include using namespace std;   // Return 1 if char c is number boolean isnum(char c) { return (c >= 48 && c <= 57); }   // Function to check // If string is compressed or not int checkCompressed(string S, string T) {     int i = 0, j = 0;       // Iterate till S.length()     // And T.length     while (j < S.length() && i < T.length()) {         if (isnum(T[i]) == false) {               // If its not equal             // Then return 0             if (S[j] != T[i]) {                 return 0;             }             j++;         }         else {             int ans = T[i] - 48;               // Iterate till we get number             // In T string             while (isnum(T[++i])) {                 ans *= 10;                 ans += T[i] - 48;             }             j += ans;             i--;         }         i++;     }       // It j not equal to S string length     // Then return 0     if (j != S.length()) {         return 0;     }     return 1; }   // Driver code int main() {     string S = "HelloWorld";     string T = "H2l4l1";     cout << checkCompressed(S, T) << endl;     return 0; }

Java

 // Java code for the above approach: import java.util.*;   class GFG{   // Return 1 if char c is number static boolean isnum(char c) { return (c >= 48 && c <= 57); }   // Function to check // If String is compressed or not static int checkCompressed(char[] S, char[] T) {     int i = 0, j = 0;       // Iterate till S.length()     // And T.length     while (j < S.length && i < T.length) {         if (isnum(T[i]) == false) {               // If its not equal             // Then return 0             if (S[j] != T[i]) {                 return 0;             }             j++;         }         else {             int ans = T[i] - 48;               // Iterate till we get number             // In T String             while (i

Python3

 # python3 code for the above approach:   # Return 1 if char c is number def isnum(c):     return ord(c) >= 48 and ord(c) <= 57   # Function to check # If string is compressed or not def checkCompressed(S, T):       i, j = 0, 0       # Iterate till S.length()     # And T.length     while (j < len(S) and i < len(T)):         if (isnum(T[i]) == False):                           # If its not equal                         # Then return 0             if (S[j] != T[i]):                 return 0               j += 1           else:             ans = ord(T[i]) - 48               # Iterate till we get number             # In T string             i += 1             while (i < len(T) and isnum(T[i])):                 ans *= 10                 ans += T[i] - 48                 i += 1               j += ans             i -= 1           i += 1           # It j not equal to S string length         # Then return 0     if (j != len(S)):         return 0       return 1   # Driver code if __name__ == "__main__":       S = "HelloWorld"     T = "H2l4l1"     print(checkCompressed(S, T))       # This code is contributed by rakeshsahni

C#

 // C# code for the above approach: using System;   public class GFG{     // Return 1 if char c is number   static boolean isnum(char c) { return (c >= 48 && c <= 57); }     // Function to check   // If String is compressed or not   static int checkCompressed(char[] S, char[] T)   {     int i = 0, j = 0;       // Iterate till S.length()     // And T.length     while (j < S.Length && i < T.Length) {       if (isnum(T[i]) == false) {           // If its not equal         // Then return 0         if (S[j] != T[i]) {           return 0;         }         j++;       }       else {         int ans = T[i] - 48;           // Iterate till we get number         // In T String         while (i

Javascript



Output

1

Time Complexity: O(max (|S|, |T|) )
Auxiliary Space: O(1)

My Personal Notes arrow_drop_up