Related Articles

Related Articles

Sum of all possible strings obtained by removal of non-empty substrings
  • Last Updated : 18 Nov, 2020

Given numerical string str consisting of N integers, the task is to find the sum of all possible resulting strings after removing non-empty substrings.

Examples:

Input: str = “205”
Output: 57
Explanation: Substrings that can be removed are “2”, “0”, “5”, “20”, “05”, “205”. The resultant strings are “05”, “25”, “20”, “5”, “2”, “0” respectively. Therefore, the sum will be 57.

Input: str = “1234”
Output: 680
Explanation: Substrings that can be removed are “1”, “2”, “3”, “4”, “12”, “23”, “34”, “123”, “234”, “1234”. The resultant strings are “234”, “134”, “124”, “123”, “34”, “14”, “12”, “4”, “1”, “0” respectively. Therefore, the sum will be 680.

Approach: To solve the problem, the following observations need to be made:



Illustration: 
Let str = “1234” 
All strings possible by removal of non-empty substrings and position of each character in these strings are as follows:

  100 10 1
234 2 3 4
134 1 3 4
124 1 2 4
123 1 2 3
34   3 4
14   1 4
12   1 2
4     4
1     1
0     0

From the above table, get the contribution at every index, for exampleContribution at 1 -> ((1 + 2 + 3) * 1 + 4 * 6) * 1

Contribution at 10 -> ((1 + 2) * 2 + 3 * 3) * 10

Contribution at 100 -> ((1) * 3 + 2 * 1) * 100

Thus, generate a general formula for every index, i.e

Contribution at 10x = (∑(n – x – 2) * (x + 1) + str[n – x – 1] * (n – x – 1)th term of Triangular Number) * 10x

Follow the steps below to solve the problem:  

  • Pre-compute powers of 10 and store in an array powers[].
  • Store the prefix sum of the digits of the given numerical string in array pref[].
  • Applying the above formula obtained, for every x from 0 to N – 1, calculate the sum.

Below is the implementation of the above approach:

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ program for the above approach
#include <bits/stdc++.h>
using namespace std;
 
const int N = 10;
 
int pref[N], power[N];
 
// Function to convert a character
// to its equivalent digit
int toDigit(char ch)
{
    return (ch - '0');
}
 
// Function to precompute powers of 10
void powerOf10()
{
    power[0] = 1;
    for (int i = 1; i < N; i++)
        power[i] = power[i - 1] * 10;
}
 
// Function to precompute prefix sum
// of numerical strings
void precomputePrefix(string str, int n)
{
    pref[0] = str[0] - '0';
    for (int i = 1; i < n; i++)
        pref[i] = pref[i - 1]
                  + toDigit(str[i]);
}
 
// Function to return the i-th
// term of Triangular Number
int triangularNumber(int i)
{
    int res = i * (i + 1) / 2;
    return res;
}
 
// Function to return the sum
// of all resulting strings
int sumOfSubstrings(string str)
{
    int n = str.size();
 
    // Precompute powers of 10
    powerOf10();
 
    // Precompute prefix sum
    precomputePrefix(str, n);
 
    // Initialize result
    int ans = 0;
 
    for (int i = 0; i < n - 1; i++) {
 
        // Apply the above general
        // formula for every i
        ans += (pref[n - i - 2] * (i + 1)
                + toDigit(str[n - i - 1])
                      * triangularNumber(
                            n - i - 1))
               * power[i];
    }
 
    // Return the answer
    return ans;
}
 
// Driver Code
int main()
{
    string str = "1234";
 
    // Function Call
    cout << sumOfSubstrings(str);
 
    return 0;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java program for the
// above approach
import java.util.*;
class GFG{
 
static int N = 10;
static int []pref = new int[N];
static int[] power = new int[N];
 
// Function to convert a
// character to its equivalent
// digit
static int toDigit(char ch)
{
  return (ch - '0');
}
 
// Function to precompute
// powers of 10
static void powerOf10()
{
  power[0] = 1;
   
  for (int i = 1; i < N; i++)
    power[i] = power[i - 1] * 10;
}
 
// Function to precompute prefix sum
// of numerical Strings
static void precomputePrefix(char[] str,
                             int n)
{
  pref[0] = str[0] - '0';
   
  for (int i = 1; i < n; i++)
    pref[i] = pref[i - 1] +
              toDigit(str[i]);
}
 
// Function to return the i-th
// term of Triangular Number
static int triangularNumber(int i)
{
  int res = i * (i + 1) / 2;
  return res;
}
 
// Function to return the sum
// of all resulting Strings
static int sumOfSubStrings(String str)
{
  int n = str.length();
 
  // Precompute powers of 10
  powerOf10();
 
  // Precompute prefix sum
  precomputePrefix(
  str.toCharArray(), n);
 
  // Initialize result
  int ans = 0;
 
  for (int i = 0; i < n - 1; i++)
  {
    // Apply the above general
    // formula for every i
    ans += (pref[n - i - 2] * (i + 1) +
            toDigit(str.charAt(n - i - 1)) *
            triangularNumber(n - i - 1)) *
            power[i];
  }
 
  // Return the answer
  return ans;
}
 
// Driver Code
public static void main(String[] args)
{
  String str = "1234";
 
  // Function Call
  System.out.print(sumOfSubStrings(str));
}
}
 
// This code is contributed by 29AjayKumar

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python 3 program for the
# above approach
N = 10
pref = [0] * N
power = [0] * N
 
# Function to convert a
# character to its equivalent
# digit
def toDigit(ch):
   
    return (ord(ch) -
            ord('0'))
 
# Function to precompute
# powers of 10
def powerOf10():
 
    power[0] = 1
    for i in range(1, N):
        power[i] = power[i - 1] * 10
 
# Function to precompute prefix sum
# of numerical strings
def precomputePrefix(st, n):
 
    pref[0] = (ord(st[0]) -
               ord('0'))
    for i in range(1, n):
        pref[i] = (pref[i - 1] +
                   toDigit(st[i]))
 
# Function to return the i-th
# term of Triangular Number
def triangularNumber(i):
 
    res = i * (i + 1) // 2
    return res
 
# Function to return the sum
# of all resulting strings
def sumOfSubstrings(st):
 
    n = len(st)
 
    # Precompute powers
    # of 10
    powerOf10()
 
    # Precompute prefix
    # sum
    precomputePrefix(st, n)
 
    # Initialize result
    ans = 0
 
    for i in range(n - 1):
 
        # Apply the above general
        # formula for every i
        ans += ((pref[n - i - 2] * (i + 1) +
                 toDigit(st[n - i - 1]) *
                 triangularNumber(n - i - 1)) *
                 power[i])
 
    # Return the answer
    return ans
 
# Driver Code
if __name__ == "__main__":
 
    st = "1234"
 
    # Function Call
    print(sumOfSubstrings(st))
 
# This code is contributed by Chitranayal

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# program for the
// above approach
using System;
class GFG{
 
static int N = 10;
static int []pref = new int[N];
static int[] power = new int[N];
 
// Function to convert a
// character to its equivalent
// digit
static int toDigit(char ch)
{
  return (ch - '0');
}
 
// Function to precompute
// powers of 10
static void powerOf10()
{
  power[0] = 1;
   
  for (int i = 1; i < N; i++)
    power[i] = power[i - 1] * 10;
}
 
// Function to precompute prefix sum
// of numerical Strings
static void precomputePrefix(char[] str,
                             int n)
{
  pref[0] = str[0] - '0';
   
  for (int i = 1; i < n; i++)
    pref[i] = pref[i - 1] +
              toDigit(str[i]);
}
 
// Function to return the i-th
// term of Triangular Number
static int triangularNumber(int i)
{
  int res = i * (i + 1) / 2;
  return res;
}
 
// Function to return the sum
// of all resulting Strings
static int sumOfSubStrings(String str)
{
  int n = str.Length;
 
  // Precompute powers of 10
  powerOf10();
 
  // Precompute prefix sum
  precomputePrefix(str.ToCharArray(), n);
 
  // Initialize result
  int ans = 0;
 
  for (int i = 0; i < n - 1; i++)
  {
    // Apply the above general
    // formula for every i
    ans += (pref[n - i - 2] * (i + 1) +
            toDigit(str[n - i - 1]) *
            triangularNumber(n - i - 1)) *
            power[i];
  }
 
  // Return the answer
  return ans;
}
 
// Driver Code
public static void Main(String[] args)
{
  String str = "1234";
 
  // Function Call
  Console.Write(sumOfSubStrings(str));
}
}
 
// This code is contributed by 29AjayKumar

chevron_right


Output: 

680









 

Time Complexity: O(N), where N is the length of the string. 
Auxiliary Space: O(1)

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.




My Personal Notes arrow_drop_up
Recommended Articles
Page :