Sum of all substrings of a string representing a number

Try it on GfG Practice

Given an integer represented as a string, we need to get the sum of all possible substrings of this string.

Note: It is guaranteed that sum of all substring will fit within a 32-bit integer.

Examples:  

Input: s = "6759"
Output: 8421
Explanation: sum = 6 + 7 + 5 + 9 + 67 + 75 +
59 + 675 + 759 + 6759
= 8421

Input: s = "16"
Output: 23
Explanation: sum = 1 + 6 + 16 = 23

Input: s = “421”
Output: 491
Explanation: Sum = 4 + 2 + 1 + 42 + 21 + 421 = 491

[Naive Approach] Using Nested Loop - O(n^2) Time and O(1) Space

Generates every possible substring of the numeric string and treats each substring as a number (not just as characters). Then it adds the value of each such number to a running total.

#include <iostream>
using namespace std;

// Function to calculate the sum of all substrings of a numeric string
int sumSubstrings(string &s) {
    
    // Final answer to store the sum of all substrings
    int ans = 0;              
    // Length of the input string
    int n = s.size();         

    // Iterate through each starting index of substring
    for (int i = 0; i < n; i++) {
        // Temporary variable to hold current substring value
        int temp = 0;        

        // Generate all substrings starting from index i
        for (int j = i; j < n; j++) {
            
            // Shift the previous value by one digit to the left
            temp *= 10;                       
            // Add current digit to form the number
            temp += (s[j] - '0');             
            // Add the current substring number to the answer
            ans += temp;                      
        }
    }

    return ans;
}

// Driver code to test the function
int main() {
    string s = "6759";
    
    // Output the sum of all substrings
    cout << sumSubstrings(s) << endl;         
    return 0;
}

class GfG{

    // Function to calculate the sum of all substrings of a numeric string
    static int sumSubstrings(String s) {
        // Final answer to store the sum of all substrings
        int ans = 0;

        // Length of the input string
        int n = s.length();

        // Iterate through each starting index of substring
        for (int i = 0; i < n; i++) {
            // Temporary variable to hold current substring value
            int temp = 0;

            // Generate all substrings starting from index i
            for (int j = i; j < n; j++) {
                // Shift the previous value by one digit to the left
                temp *= 10;
                // Add current digit to form the number
                temp += (s.charAt(j) - '0');
                // Add the current substring number to the answer
                ans += temp;
            }
        }

        // Return the final result
        return ans;
    }

    // Main method to test the function
    public static void main(String[] args) {
        // Input numeric string
        String s = "6759";

        // Output the sum of all substrings
        System.out.println(sumSubstrings(s));
    }
}

def sumSubstrings(s):
    # Final answer to store the sum of all substrings
    ans = 0               
    # Length of the input string
    n = len(s)            

    for i in range(n):
        # Temporary variable to hold current substring value
        temp = 0          

        for j in range(i, n):
            # Shift the previous value by one digit to the left
            temp *= 10                    
            # Add current digit to form the number
            temp += int(s[j])            
            # Add the current substring number to the answer
            ans += temp                  
    return ans

if __name__ == "__main__":
    s = "6759"
    # Output the sum of all substrings
    print(sumSubstrings(s))   

using System;

class GfG{
    // Function to calculate the sum of all substrings of a numeric string
    static int sumSubstrings(string s){
        
        // Final answer to store the sum of all substrings
        int ans = 0;

        // Length of the input string
        int n = s.Length;

        // Iterate through each starting index of substring
        for (int i = 0; i < n; i++){
            
            // Temporary variable to hold current substring value
            int temp = 0;

            // Generate all substrings starting from index i
            for (int j = i; j < n; j++){
                
                // Shift the previous value by one digit to the left
                temp *= 10;
                // Add current digit to form the number
                temp += (s[j] - '0');
                // Add the current substring number to the answer
                ans += temp;
            }
        }

        // Return the final result
        return ans;
    }

    // Main method to test the function
    public static void Main(){
        
        // Input numeric string
        string s = "6759";

        // Output the sum of all substrings
        Console.WriteLine(sumSubstrings(s));
    }
}

function sumSubstrings(s) {
    
    // Final answer to store the sum of all substrings
    let ans = 0;             
    // Length of the input string
    let n = s.length;        

    for (let i = 0; i < n; i++) {
        // Temporary variable to hold current substring value
        let temp = 0;         

        for (let j = i; j < n; j++) {
            // Shift the previous value by one digit to the left
            temp *= 10;                       
            // Add current digit to form the number
            temp += (s[j] - '0');             
            // Add the current substring number to the answer
            ans += temp;                      
        }
    }

    return ans;
}

// Driver code to test the function
let s = "6759";
// Output the sum of all substrings
console.log(sumSubstrings(s));  

8421

[Better Approach] Using Dynamic Programming - O(n) Time and O(n) Space

We can solve this problem by using dynamic programming. We can write a summation of all substrings on basis of the digit at which they are ending in that case, 
Sum of all substrings = sumofdigit[0] + sumofdigit[1] + sumofdigit[2] … + sumofdigit[n-1] where n is length of string.
Where sumofdigit[i] stores the sum of all substring ending at ith index digit, in the above example, 

Example: s = "6759"

sumofdigit[0] = 6 = 6
sumofdigit[1] = 7 + 67  = 74
sumofdigit[2] = 5 + 75  + 675 = 755
sumofdigit[3] = 9 + 59  + 759 + 6759  = 7586
Result = 8421

Now we can get the relation between sumofdigit values and can solve the question iteratively. Each sumofdigit can be represented in terms of previous value as shown below, For above example,

sumofdigit[3] = 9 + 59  + 759 + 6759
                     = 9 + 50 + 9 + 750 + 9 + 6750 + 9
                     = 9*4 + 10*(5 + 75 + 675)
                     = 9*4 + 10*(sumofdigit[2])

In general, sumofdigit[i]  =  (i+1)*s[i] + 10*sumofdigit[i-1]

Follow the given steps to solve the problem:

• Declare an array of size n to store the sum of previous digits, processed so far, and a variable result
• Traverse over the string and for every character
  • Set sumOfDigit[i] = (i + 1) * toDigit(s[i]) + 10 * sumOfDigit[i-1]
  • Add the value of sumOfDigit[i] to result
• Return result

// C++ program to print sum of all substring of
// a sber represented as a string
#include <bits/stdc++.h>
using namespace std;

// Utility method to convert character digit to
// integer digit
int toDigit(char ch) { return (ch - '0'); }

// Returns sum of all substring of s
int sumSubstrings(string s){
    
    int n = s.length();
    // allocate memory equal to length of string
    int sumofdigit[n];

    // initialize first value with first digit
    sumofdigit[0] = toDigit(s[0]);
    int res = sumofdigit[0];

    // loop over all digits of string
    for (int i = 1; i < n; i++) {
        int si = toDigit(s[i]);

        // update each sumofdigit from previous value
        sumofdigit[i]
            = (i + 1) * si + 10 * sumofdigit[i - 1];

        // add current value to the result
        res += sumofdigit[i];
    }

    return res;
}

// Driver code
int main(){
    
    string s = "6759";
      // Function call
    cout << sumSubstrings(s) << endl;
    return 0;
}

// Java program to print sum of all substring of
// a sber represented as a string
import java.util.Arrays;

class GfG {

    // Returns sum of all substring of s
    static int sumSubstrings(String s){
        int n = s.length();

        // allocate memory equal to length of string
        int sumofdigit[] = new int[n];

        // initialize first value with first digit
        sumofdigit[0] = s.charAt(0) - '0';
        int res = sumofdigit[0];

        // loop over all digits of string
        for (int i = 1; i < n; i++) {
            int si = s.charAt(i) - '0';

            // update each sumofdigit from previous value
            sumofdigit[i]
                = (i + 1) * si + 10 * sumofdigit[i - 1];

            // add current value to the result
            res += sumofdigit[i];
        }

        return res;
    }

    // Driver Code 
    public static void main(String[] args){
        String s = "6759";

          // Function call
        System.out.println(sumSubstrings(s));
    }
}

# Python3 program to print
# sum of all substring of
# a sber represented as
# a string
def sumSubstrings(s):
    n = len(s)

    # allocate memory equal
    # to length of string
    sumofdigit = []

    # initialize first value
    # with first digit
    sumofdigit.append(int(s[0]))
    res = sumofdigit[0]

    # loop over all
    # digits of string
    for i in range(1, n):
        si = int(s[i])

        # update each sumofdigit
        # from previous value
        sumofdigit.append((i + 1) *
                          si + 10 * sumofdigit[i - 1])

        # add current value
        # to the result
        res += sumofdigit[i]

    return res


# Driver Code
if __name__ == '__main__':
  s = "6759"
  print(sumSubstrings(s))

// C# program to print sum of
// all substring of a sber
// represented as a string
using System;

class GfG {

    // Returns sum of all
    // substring of s
    static int sumSubstrings(String s){
        
        int n = s.Length;

        // allocate memory equal to
        // length of string
        int[] sumofdigit = new int[n];

        // initialize first value
        // with first digit
        sumofdigit[0] = s[0] - '0';
        int res = sumofdigit[0];

        // loop over all digits
        // of string
        for (int i = 1; i < n; i++) {
            int si = s[i] - '0';

            // update each sumofdigit
            // from previous value
            sumofdigit[i]
                = (i + 1) * si + 10 * sumofdigit[i - 1];

            // add current value
            // to the result
            res += sumofdigit[i];
        }

        return res;
    }

    // Driver code
    public static void Main(){
        
        String s = "6759";
        // Function call
        Console.Write(sumSubstrings(s));
    }
}

// Returns sum of all
// substring of s
function sumSubstrings(s){
    
    let n = s.length;

    // allocate memory equal to
    // length of string
    let sumofdigit = new Array(n);

    // initialize first value
    // with first digit
    sumofdigit[0] = s[0].charCodeAt() - "0".charCodeAt();
    let res = sumofdigit[0];

    // loop over all digits
    // of string
    for (let i = 1; i < n; i++) {
        let si = s[i].charCodeAt() - "0".charCodeAt();

        // update each sumofdigit
        // from previous value
        sumofdigit[i]
            = (i + 1) * si + 10 * sumofdigit[i - 1];

        // add current value
        // to the result
        res += sumofdigit[i];
    }

    return res;
}

// Driver Code
let s = "6759";
console.log(sumSubstrings(s));

8421

[Expected Approach] Within Constant Space - O(n) Time and O(n) Space

After analyse each digit contributes to the sum of all substrings by observing its position and place value.

Let number be s = "6759".

1 10 100 1000
6 1 1 1 1
7 2 2 2
5 3 3
9 4

The above table indicates that, when all the substrings are converted further to the ones, tens, hundreds etc.. form, each index of the string will have some fixed occurrence. The 0'th index will have 1 occurrence each of ones, tens etc. The 1st will have 2, 2nd will have 3 and so on. Each digit at index i appears in exactly (i + 1) substrings ending at that digit. Additionally, its contribution is scaled by powers of 10 based on its position from the right.

So the total sum of all substrings can be expressed by evaluating how each digit contributes based on its position. For the string s = "6759", the sum becomes:

sum = 6*(1*1 + 1*10 + 1*100 + 1*1000) + 7*(2*1 + 2*10 + 2*100) +
5*(3*1 + 3*10) + 9*(4*1)
= 6*1*(1111) + 7*2*(111) + 5*3*(11) + 9*4*(1)
= 6666 + 1554 + 165 + 36
= 8421

Now, to handle the multiplication we will be having a multiplying factor which starts from 1. It's clear from the example that the multiplying factor(in reverse) is 1, 11, 111, ... and so on. So the multiplication will be based on three factors. number, its index, and a multiplying factor. 

// C++ program to print sum of all substring of
// a sber represented as a string
#include <bits/stdc++.h>
using namespace std;

// Returns sum of all substring of s
int sumSubstrings(string s){
    
    long long int sum = 0; 
    
    // Here traversing the array in reverse
    // order.Initializing loop from last element.
    // mf is multiplying factor.
    long long int mf = 1;
    for (int i=s.size()-1; i>=0; i--){
        
        // Each time sum is added to its previous
        // sum. Multiplying the three factors as explained above.
        // s[i]-'0' is done to convert char to int.
        sum += (s[i]-'0')*(i+1)*mf;

        // Making new multiplying factor as explained above.
        mf = mf*10 + 1;
    }

    return sum;
}

//  Driver code
int main(){
    
    string s = "6759";
    cout << sumSubstrings(s) << endl;
    return 0;
}

// Java program to print sum of all substring of
// a sber represented as a string
import java.util.Arrays;

class GfG {
    
    // Returns sum of all substring of s
    static int sumSubstrings(String s){
        
        // Initialize result
        int sum = 0; 
     
        // Here traversing the array in reverse
        // order.Initializing loop from last
        // element.
        // mf is multiplying factor.
        int mf = 1;
        for (int i = s.length() - 1; i >= 0; i --){
            
            // Each time sum is added to its previous
            // sum. Multiplying the three factors as
            // explained above.
            // s[i]-'0' is done to convert char to int.
            sum += (s.charAt(i) - '0') * (i + 1) * mf;
     
            // Making new multiplying factor as
            // explained above.
            mf = mf * 10 + 1;
        }
     
        return sum;
    }
    
         
    //  Driver Code
    public static void main(String[] args){
        
        String s = "6759";
            
        System.out.println(sumSubstrings(s));
            
    }
}

# Python3 program to print sum of all substring of
# a stdber represented as a string

# Returns sum of all substring of std
def sumSubstrings(s):
    
    # Initialize result
    sum = 0 

    # Here traversing the array in reverse
    # order.Initializing loop from last
    # element.
    # mf is multiplying factor.
    mf = 1
    for i in range(len(s) - 1, -1, -1):

        # Each time sum is added to its previous
        # sum. Multiplying the three factors as
        # explained above.
        # int(s[i]) is done to convert char to int.
        sum = sum + (int(s[i])) * (i + 1) * mf

        # Making new multiplying factor as
        # explained above.
        mf = mf * 10 + 1

    return sum

# Driver Code
if __name__=='__main__':
    s = "6759"
    print(sumSubstrings(s))

// C# program to print sum of all substring of
// a sber represented as a string
using System;
        
class GfG {
    
    // Returns sum of all substring of s
    static int sumSubstrings(string s){
        
        int sum = 0; 
        
        // Here traversing the array in reverse
        // order.Initializing loop from last
        // element.
        // mf is multiplying factor.
        int mf = 1;
        
        for (int i = s.Length - 1; i >= 0; i --){
            
            // Each time sum is added to its previous
            // sum. Multiplying the three factors as
            // explained above.
            // s[i]-'0' is done to convert char to int.
            sum += (s[i] - '0') * (i + 1) * mf;
    
            // Making new multiplying factor as
            // explained above.
            mf = mf * 10 + 1;
        }
    
        return sum;
    }
    
        
    // Driver Code
    public static void Main() {
        
        string s = "6759";
        Console.WriteLine(sumSubstrings(s));
        
    }
}

// Function returns sum of all substring of s
function sumSubstrings(s){

    let sum = 0;

    // Here traversing the array in reverse
    // order.Initializing loop from last
    // element.
    // mf is multiplying factor.
    let mf = 1;

    for (let i = s.length - 1; i >= 0; i--) {

        // Each time sum is added to its previous
        // sum. Multiplying the three factors as
        // explained above.
        // s[i]-'0' is done to convert char to int.
        sum += (s[i].charCodeAt() - "0".charCodeAt())
               * (i + 1) * mf;

        // Making new multiplying factor as
        // explained above.
        mf = mf * 10 + 1;
    }

    return sum;
}

// Driver Code
let s = "6759";
console.log(sumSubstrings(s));

8421