Skip to content
Related Articles

Related Articles

Sum of all distances between occurrences of same characters in a given string
  • Difficulty Level : Hard
  • Last Updated : 17 May, 2021

Given a string S, the task is to find the sum of distances between all pairs of indices from the given string which contains the same character.

Examples:

Input: S = “ababa”
Output: 10
Explanation:
The pair of indices having same character are: (0, 2) (0, 4) (1, 3) (2, 4)
Sum of absolute differences between these pair of indices = |2 – 0| + |4 – 0| + |1 – 3| + |2 – 4| = 10. 
Therefore, the required answer is 10.

Input: S = “ttt”
Output: 4

Naive Approach: The simplest approach to solve the problem is to traverse the string and for each character encountered, traverse the remaining string on its right to find occurrences of that character. For every repetition of characters found, keep adding the absolute difference between the concerned indices to the answer. Finally, print the sum obtained. 



Time Complexity: O(N2) 
Auxiliary Space: O(1)

Below is the implementation of the above approach:

C++




// C++ program for the above approach
 
#include <bits/stdc++.h>
using namespace std;
 
// Function to calculate the sum
// of distances between occurrences
// of same characters in a string
int findSum(string s)
{
    int sum = 0;
    for (int i = 0; i < s.size(); i++) {
        for (int j = i + 1; j < s.size(); j++) {
 
            // If similar characters are found
            if (s[i] == s[j]) {
 
                // Add the difference
                // of their positions
                sum += (j - i);
            }
        }
    }
 
    // Return the answer
    return sum;
}
 
// Driver Code
int main()
{
    string s = "ttt";
    cout << findSum(s) << endl;
}
Java



// Java program for the above approach
import java.util.*;
class GFG{
 
// Function to calculate the sum
// of distances between occurrences
// of same characters in a String
static int findSum(String s)
{
    int sum = 0;
    for (int i = 0; i < s.length(); i++)
    {
        for (int j = i + 1; j < s.length(); j++)
        {
            // If similar characters are found
            if (s.charAt(i) == s.charAt(j))
            {
                // Add the difference
                // of their positions
                sum += (j - i);
            }
        }
    }
 
    // Return the answer
    return sum;
}
 
// Driver Code
public static void main(String[] args)
{
    String s = "ttt";
    System.out.print(findSum(s) + "\n");
}
}
// This code is contributed by shikhasingrajput
Python3



# Python3 program for the above approach
  
# Function to calculate the sum
# of distances between occurrences
# of same characters in a string
def findSum(s):
     
    sum = 0
    for i in range(len(s)):
        for j in range(i + 1, len(s)):
  
            # If similar characters are found
            if (s[i] == s[j]):
  
                # Add the difference
                # of their positions
                sum += (j - i)
  
    # Return the answer
    return sum
 
# Driver Code
s = "ttt"
 
print(findSum(s))
 
# This code is contributed by code_hunt
C#



// C# program for
// the above approach
using System;
class GFG{
 
// Function to calculate the sum
// of distances between occurrences
// of same characters in a String
static int findSum(String s)
{
  int sum = 0;
  for (int i = 0; i < s.Length; i++)
  {
    for (int j = i + 1; j < s.Length; j++)
    {
      // If similar characters
      // are found
      if (s[i] == s[j])
      {
        // Add the difference
        // of their positions
        sum += (j - i);
      }
    }
  }
 
  // Return the answer
  return sum;
}
 
// Driver Code
public static void Main(String[] args)
{
  String s = "ttt";
  Console.Write(findSum(s) + "\n");
}
}
  
// This code is contributed by shikhasingrajput
Javascript



<script>
// javascript program for the
// above approach
 
// Function to calculate the sum
// of distances between occurrences
// of same characters in a String
function findSum(s)
{
    let sum = 0;
    for (let i = 0; i < s.length; i++)
    {
        for (let j = i + 1; j < s.length; j++)
        {
            // If similar characters are found
            if (s[i] == s[j])
            {
                // Add the difference
                // of their positions
                sum += (j - i);
            }
        }
    }
  
    // Return the answer
    return sum;
}
  
// Driver Code
 
     let s = "ttt";
    document.write(findSum(s) + "<br/>");
 
// This code is contributed by target_2.
</script>
Output: 
4
Efficient Approach: The above approach can be optimized based on the following observations:
  • Initially for every character, assume that all its similar characters are at index 0.
  • With the above assumption, the required sum becomes equal to:
Number of previously visited similar characters * Index of the character – sum of distances of those similar characters from index 0
Therefore, follow the steps below to solve the problem:
  • Initialize two arrays visited[] and distance[] to store the frequency of each character present in the string and the distance between the previous occurrences of each character respectively.
  • Traverse the string and for every character encountered, i.e. S[i], update the following:
    • Add visited[S[i] * i – distance[S[i]] to the required sum.
    • Increment visited[S[i]] to increase frequency of characters.
    • Increase distance[S[i]] by i, to increase the distance from the previous occurrence of S[i], considered to be 0.
  • Once the above steps are completed, print the sum obtained.
Below is the implementation of the above approach :
C++



// C++ program for the above approach
 
#include <bits/stdc++.h>
using namespace std;
 
// Function to calculate the sum
// of distances between occurrences
// of same characters in a string
int findSum(string s)
{
    int visited[256];
    int distance[256];
 
    // Initially make all the distances
    // and number of characters visited as 0
    for (int i = 0; i < 256; i++) {
        visited[i] = 0;
        distance[i] = 0;
    }
 
    int sum = 0;
 
    for (int i = 0; i < s.size(); i++) {
 
        // Assuming that all the similar
        // characters are located at index 0
 
        // Add visited[s[i]]*i to sum
        // and subtract the distances of
        // characters from index 0
        sum += visited[s[i]] * i
               - distance[s[i]];
 
        // Increment the number of
        // visited characters
        visited[s[i]]++;
 
        // Add the distance of the
        // character from position 0
        // i.e., (i - 0) = i
        distance[s[i]] += i;
    }
 
    // Return the answer
    return sum;
}
 
// Driver code
int main()
{
    string s = "ttt";
 
    // Function call
    cout << findSum(s) << endl;
}
Java



// Java program for the above approach
import java.io.*;
 
class GFG{
 
// Function to calculate the sum
// of distances between occurrences
// of same characters in a string
static int findSum(String s)
{
    int[] visited = new int[256];
    int[] distance = new int[256];
 
    // Initially make all the distances
    // and number of characters visited as 0
    for(int i = 0; i < 256; i++)
    {
        visited[i] = 0;
        distance[i] = 0;
    }
 
    int sum = 0;
 
    for(int i = 0; i < s.length(); i++)
    {
         
        // Assuming that all the similar
        // characters are located at index 0
 
        // Add visited[s[i]]*i to sum
        // and subtract the distances of
        // characters from index 0
        sum += visited[s.charAt(i)] * i -
              distance[s.charAt(i)];
 
        // Increment the number of
        // visited characters
        visited[s.charAt(i)]++;
 
        // Add the distance of the
        // character from position 0
        // i.e., (i - 0) = i
        distance[s.charAt(i)] += i;
    }
 
    // Return the answer
    return sum;
}
 
// Driver code
public static void main (String[] args)
{
    String s = "ttt";
     
    // Function call
    System.out.println(findSum(s));
}
}
 
// This code is contributed by offbeat
Python3



# Python3 program for the above approach
 
# Function to calculate the sum
# of distances between occurrences
# of same characters in a string
def findSum(s):
    visited = [0 for i in range(256)];
    distance = [0 for i in range(256)];
 
    # Initially make all
    # the distances and number
    # of characters visited as 0
    for i in range(256):
        visited[i] = 0;
        distance[i] = 0;   
 
    sum = 0;
 
    for i in range(len(s)):
 
        # Assuming that all the similar
        # characters are located at index 0
 
        # Add visited[s[i]]*i to sum
        # and subtract the distances of
        # characters from index 0
        sum += visited[ord(s[i])] * i - distance[ord(s[i])];
 
        # Increment the number of
        # visited characters
        visited[ord(s[i])] += 1;
 
        # Add the distance of the
        # character from position 0
        # i.e., (i - 0) = i
        distance[ord(s[i])] += i;   
 
    # Return the answer
    return sum;
 
# Driver code
if __name__ == '__main__':
   
    s = "ttt";
 
    # Function call
    print(findSum(s));
 
# This code is contributed by Rajput-Ji
C#



// C# program for the above approach
using System;
 
class GFG{
 
// Function to calculate the sum
// of distances between occurrences
// of same characters in a string
static int findSum(String s)
{
    int[] visited = new int[256];
    int[] distance = new int[256];
 
    // Initially make all the distances
    // and number of characters visited as 0
    for(int i = 0; i < 256; i++)
    {
        visited[i] = 0;
        distance[i] = 0;
    }
     
    int sum = 0;
     
    for(int i = 0; i < s.Length; i++)
    {
         
        // Assuming that all the similar
        // characters are located at index 0
 
        // Add visited[s[i]]*i to sum
        // and subtract the distances of
        // characters from index 0
        sum += visited[s[i]] * i -
              distance[s[i]];
 
        // Increment the number of
        // visited characters
        visited[s[i]]++;
 
        // Add the distance of the
        // character from position 0
        // i.e., (i - 0) = i
        distance[s[i]] += i;
    }
 
    // Return the answer
    return sum;
}
 
// Driver code
public static void Main(String[] args)
{
    String s = "ttt";
     
    // Function call
    Console.WriteLine(findSum(s));
}
}
 
// This code is contributed by Amit Katiyar
Output: 
4
Time Complexity: O(N) 
Auxiliary Space: O(1)
Attention reader! Don’t stop learning now. Get hold of all the important mathematical concepts for competitive programming with the Essential Maths for CP Course at a student-friendly price. To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.
My Personal Notes
arrow_drop_up
Next

Minimum replacement of pairs by their LCM required to reduce given array to its LCM
Recommended Articles
Page :
Swap all occurrences of two characters to get lexicographically smallest string
18, Jul 19
Modify string by replacing all occurrences of given characters by specified replacing characters
14, Apr 21
Check if a string can be made palindromic by swapping pairs of characters from indices having unequal characters in a Binary String
31, Mar 21
Longest Common Subsequence (LCS) by repeatedly swapping characters of a string with characters of another string
22, Mar 21
Modify characters of a string by adding integer values of same-indexed characters from another given string
01, Mar 21
Group all occurrences of characters according to first appearance
09, Dec 16
Smallest character in a string having minimum sum of distances between consecutive repetitions
08, Sep 20
Longest substring between any pair of occurrences ōf similar characters
20, Oct 20
Maximize count of non overlapping substrings which contains all occurrences of its characters
19, Nov 20
Smallest string obtained by removing all occurrences of 01 and 11 from Binary String
27, Oct 20
Minimize length of a string by removing occurrences of another string from it as a substring
19, Jan 21
Most frequent character in a string after replacing all occurrences of X in a Binary String
19, Feb 21
Maximum consecutive occurrences of a string in another given string
04, Dec 20
Minimize a string by removing all occurrences of another string
16, Dec 20
Count occurrences of a string that can be constructed from another given string
28, Jan 19
Modify string by inserting characters such that every K-length substring consists of unique characters only
14, Feb 21
Modify string by sorting characters after removal of characters whose frequency is not equal to power of 2
23, Mar 21
Count of ungrouped characters after dividing a string into K groups of distinct characters
14, May 20
Permutation of a string with maximum number of characters greater than its adjacent characters
18, Jul 18
Minimum cost to remove the spaces between characters of a String by rearranging the characters
31, Aug 20
Rearrange the characters of the string such that no two adjacent characters are consecutive English alphabets
25, Jul 19
Make all characters of a string same by minimum number of increments or decrements of ASCII values of characters
10, Feb 21
Subsequences generated by including characters or ASCII value of characters of given string
02, Dec 20
Min flips of continuous characters to make all characters same in a string
12, Jul 17
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
prasunareddy
@prasunareddy
Vote for difficulty
Current difficulty :
Hard





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox