Skip to content
Related Articles

Related Articles

Improve Article

Repeat substrings of the given String required number of times

  • Difficulty Level : Easy
  • Last Updated : 11 Sep, 2020

Given a string str, the task is to repeat every substring of the string X number of times where X is the number composed of the consecutive digits present just after the substring in the original string. For example, if str = “g1e2ks1” then the resultant string will be “geeks”.

Examples:

Input: str = “2a10bd3”
Output: aaaaaaaaaabdbdbd
First digit “2” is unnecessary as there is no valid substring before it.
“a” will be repeated 10 times and then “bd” will be repeated thrice.

Input: str = “g1ee1ks1for1g1e2ks1”
Output: geeksforgeeks

Approach: Find the first valid substring i.e. the substring which doesn’t contain any digit then parse the integer present just after the found substring using parseInt() and then repeat the found substring the required number of times. Repeat these steps for all valid substrings and then print the resultant string.



Below is the implementation of the above approach:

C++




// C++ implementation of the approach
#include <bits/stdc++.h>
using namespace std;
  
// Function that returns true if the
// passed character is a digit
bool isDigit(char ch)
{
    if (ch >= '0' && ch <= '9')
        return true;
    return false;
}
  
// Function to return the next index
// of a non-digit character in the string
// starting at the index i (returns -1 if
// no such index is found)
int nextNonDigit(string str, int i)
{
    // If the character at index i is a digit
    // then skip to the next character
    while (i < str.length() && isDigit(str[i]))
    {
        i++;
    }
  
    // If no such index was found
    if (i >= str.length())
        return -1;
    return i;
}
  
// Function to append str the given number
// of times to the StringBuilder
void appendRepeated(string &sb, string str, int times)
{
    for (int i = 0; i < times; i++)
        sb.append(str);
}
  
// Function to return the string after
// performing the given operations
string findString(string str, int n)
{
    // To build the resultant string
    string sb = "";
  
    // Index of the first non-digit
    // character in the string
    int startStr = nextNonDigit(str, 0);
  
    // While there are substrings that
    // do not consist of digits
    while (startStr != -1)
    {
  
        // Find the ending of the substring
        int endStr = startStr;
        while ((endStr + 1) < n && !isDigit(str[endStr + 1]))
        {
            endStr++;
        }
  
        // Starting index of the number
        int startNum = endStr + 1;
  
        // If no digit appears after
        // the current substring
        if (startNum == -1)
            break;
  
        // Find the index at which the
        // current number ends
        int endNum = startNum;
        while ((endNum + 1) < n && isDigit(str[endNum + 1]))
        {
            endNum++;
        }
  
        // Parse the number from the substring
        int num = str[startNum] - '0';
  
        // Repeat the current substring required number of times
        appendRepeated(sb, str.substr(startStr, endStr + 1 - startStr), num);
  
        // Find the next non-digit character index
        startStr = nextNonDigit(str, endStr + 1);
    }
  
    // Return the resultant string
    return sb;
}
  
// Driver Code
int main()
{
    string str = "g1ee1ks1for1g1e2ks1";
    int n = str.length();
  
    cout << findString(str, n) << endl;
  
    return 0;
}
  
// This code is contributed by
// sanjeev2552

Java




// Java implementation of the approach
class GFG {
  
    // Function that returns true if the
    // passed character is a digit
    static boolean isDigit(char ch)
    {
        if (ch >= '0' && ch <= '9')
            return true;
        return false;
    }
  
    // Function to return the next index
    // of a non-digit character in the string
    // starting at the index i (returns -1 if
    // no such index is found)
    static int nextNonDigit(String str, int i)
    {
  
        // If the character at index i is a digit
        // then skip to the next character
        while (i < str.length()
               && isDigit(str.charAt(i))) {
            i++;
        }
  
        // If no such index was found
        if (i >= str.length())
            return -1;
        return i;
    }
  
    // Function to append str the given number
    // of times to the StringBuilder
    static void appendRepeated(StringBuilder sb,
                               String str, int times)
    {
        for (int i = 0; i < times; i++)
            sb.append(str);
    }
  
    // Function to return the string after
    // performing the given operations
    static String findString(String str, int n)
    {
  
        // To build the resultant string
        StringBuilder sb = new StringBuilder("");
  
        // Index of the first non-digit
        // character in the string
        int startStr = nextNonDigit(str, 0);
  
        // While there are substrings that
        // do not consist of digits
        while (startStr != -1) {
  
            // Find the ending of the substring
            int endStr = startStr;
            while ((endStr + 1) < n
                   && !isDigit(str.charAt(endStr + 1))) {
                endStr++;
            }
  
            // Starting index of the number
            int startNum = endStr + 1;
  
            // If no digit appears after
            // the current substring
            if (startNum == -1)
                break;
  
            // Find the index at which the
            // current number ends
            int endNum = startNum;
            while ((endNum + 1) < n
                   && isDigit(str.charAt(endNum + 1))) {
                endNum++;
            }
  
            // Parse the number from the substring
            int num = Integer.parseInt(str.substring(startNum,
                                                     endNum + 1));
  
            // Repeat the current substring required number of times
            appendRepeated(sb, str.substring(startStr,
                                             endStr + 1), num);
  
            // Find the next non-digit character index
            startStr = nextNonDigit(str, endStr + 1);
        }
  
        // Return the resultant string
        return sb.toString();
    }
  
    // Driver code
    public static void main(String[] args)
    {
        String str = "g1ee1ks1for1g1e2ks1";
        int n = str.length();
        System.out.println(findString(str, n));
    }
}

Python3




# Python3 implementation of the approach
  
# Function that returns true if the
# passed character is a digit
def isDigit(ch):
    if ch >= '0' and ch <= '9':
        return True
    return False
  
# Function to return the next index
# of a non-digit character in the string
# starting at the index i (returns -1 if
# no such index is found)
def nextNonDigit(string, i):
  
    # If the character at index i is a digit
    # then skip to the next character
    while i < len(string) and isDigit(string[i]):
        i += 1
  
    # If no such index was found
    if i >= len(string):
        return -1
    return i
  
# Function to append str the given number
# of times to the StringBuilder
def appendRepeated(sb, string, times):
    for i in range(times):
        sb.append(string)
  
# Function to return the string after
# performing the given operations
def findString(string, n):
  
    # To build the resultant string
    sb = list()
  
    # Index of the first non-digit
    # character in the string
    startStr = nextNonDigit(string, 0)
  
    # While there are substrings that
    # do not consist of digits
    while startStr != -1:
  
        # Find the ending of the substring
        endStr = startStr
  
        while (endStr + 1 < n and not 
               isDigit(string[endStr + 1])):
            endStr += 1
  
        # Starting index of the number
        startNum = endStr + 1
  
        # If no digit appears 
        # after the current substring
        if startNum == -1:
            break
  
        # Find the index at which the
        # current number ends
        endNum = startNum
  
        while (endNum + 1 < n and
               isDigit(string[endNum + 1])):
            endNum += 1
  
        # Parse the number from the substring
        num = int(string[startNum:endNum + 1])
  
        # Repeat the current substring
        # required number of times
        appendRepeated(sb, string[startStr:endStr + 1], num)
  
        # Find the next non-digit character index
        startStr = nextNonDigit(string, endStr + 1)
  
    # Return the resultant string
    sb = ''.join(sb)
    return sb
  
# Driver code
if __name__ == "__main__":
    string = "g1ee1ks1for1g1e2ks1"
    n = len(string)
    print(findString(string, n))
  
# This code is contributed by
# sanjeev2552

C#




// C# implementation of the approach
using System;
using System.Text; 
  
class GFG{
  
// Function that returns true if the
// passed character is a digit
static bool isDigit(char ch)
{
    if (ch >= '0' && ch <= '9')
        return true;
          
    return false;
}
  
// Function to return the next index
// of a non-digit character in the string
// starting at the index i (returns -1 if
// no such index is found)
static int nextNonDigit(string str, int i)
{
  
    // If the character at index i is a digit
    // then skip to the next character
    while (i < str.Length && isDigit(str[i]))
    {
        i++;
    }
  
    // If no such index was found
    if (i >= str.Length)
        return -1;
          
    return i;
}
  
// Function to append str the given number
// of times to the StringBuilder
static void appendRepeated(StringBuilder sb,
                           string str, int times)
{
    for(int i = 0; i < times; i++)
        sb.Append(str);
}
  
// Function to return the string after
// performing the given operations
static String findString(string str, int n)
{
  
    // To build the resultant string
    StringBuilder sb = new StringBuilder("");
  
    // Index of the first non-digit
    // character in the string
    int startStr = nextNonDigit(str, 0);
  
    // While there are substrings that
    // do not consist of digits
    while (startStr != -1)
    {
  
        // Find the ending of the substring
        int endStr = startStr;
        while ((endStr + 1) < n && 
               !isDigit(str[endStr + 1]))
        {
            endStr++;
        }
  
        // Starting index of the number
        int startNum = endStr + 1;
  
        // If no digit appears after
        // the current substring
        if (startNum == -1)
            break;
  
        // Find the index at which the
        // current number ends
        int endNum = startNum;
        while ((endNum + 1) < n && 
                isDigit(str[endNum + 1]))
        {
            endNum++;
        }
  
        // Parse the number from the substring
        int num = Int32. Parse(str.Substring(
                  startNum, endNum - startNum + 1));
  
        // Repeat the current substring required
        // number of times
        appendRepeated(sb, str.Substring(
            startStr, endStr - startStr + 1), num);
  
        // Find the next non-digit character index
        startStr = nextNonDigit(str, endStr + 1);
    }
  
    // Return the resultant string
    return sb.ToString();
}
  
// Driver code
public static void Main(string[] args)
{
    string str = "g1ee1ks1for1g1e2ks1";
    int n = str.Length;
      
    Console.Write(findString(str, n));
}
}
  
// This code is contributed by rutvik_56
Output:
geeksforgeeks

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.




My Personal Notes arrow_drop_up
Recommended Articles
Page :