3110. Score of a String

EasyString

Problem Description

You are given a string s. The score of a string is defined as the sum of the absolute difference between the ASCII values of adjacent characters. The task is to return the score of s.

Intuition

The problem asks you to compute a score based on the differences in ASCII values of consecutive characters in a given string s. The intuition behind this problem is to iterate through the string character by character, calculating how different each character is from its next neighbor using their ASCII values. This is achieved by computing the absolute difference between the ASCII values of consecutive characters.

To arrive at the solution, you can use the ord() function in Python to convert each character to its ASCII value. By iterating over pairs of these values using a helper like pairwise(), you can simply sum up the absolute differences between each pair to get the desired score.

Solution Approach

The solution employs a straightforward simulation approach to achieve the task. Here's a step-by-step breakdown of the algorithm:

Convert Characters to ASCII Values:
- Use the ord() function to transform each character in the string s into its corresponding ASCII value. This is because the problem is concerned with the differences between these ASCII values.
Generate Pairs of Consecutive Characters:
- We need to work with consecutive pairs of characters. This can be efficiently done using a function like pairwise(), which iterates over the string in such a way that you can directly access consecutive pairs for comparison.
Calculate Absolute Differences:
- For each pair (a, b), compute the absolute difference abs(a - b). This represents how different two consecutive characters are in terms of their ASCII values.
Compute the Total Score:
- Sum all these absolute differences to get the total score for the string. This summation gives us the "score" described in the problem statement.

The solution captures these steps in concise Python code using a generator expression within the sum() function as shown:

class Solution:
    def scoreOfString(self, s: str) -> int:
        return sum(abs(a - b) for a, b in pairwise(map(ord, s)))

By breaking down the task into these manageable steps, the solution efficiently computes the required score of the string. The approach is optimal in terms of clarity and efficiency as it traverses the string exactly once.

Ready to land your dream job?

Unlock your dream job with a 2-minute evaluator for a personalized learning plan!

Start Evaluator

Example Walkthrough

Let's consider a simple example where the input string s is "abc".

Convert Characters to ASCII Values:
- The ASCII value of 'a' is 97.
- The ASCII value of 'b' is 98.
- The ASCII value of 'c' is 99.
Thus, the ASCII values for the string "abc" are [97, 98, 99].
Generate Pairs of Consecutive Characters:
- We create pairs of consecutive characters: (97, 98) and (98, 99).
Calculate Absolute Differences:
- For the pair (97, 98), the absolute difference is abs(97 - 98) = 1.
- For the pair (98, 99), the absolute difference is abs(98 - 99) = 1.
Compute the Total Score:
- The total score is calculated by summing the absolute differences: 1 + 1 = 2.

Thus, the score of the string "abc" is 2. The algorithm effectively iterates through the string, computing the necessary differences to determine the final score.

Solution Implementation

1from itertools import tee
2
3class Solution:
4    def scoreOfString(self, s: str) -> int:
5        # Helper function to create pairs of consecutive elements from the input iterable
6        def pairwise(iterable):
7            # tee creates two independent iterators over the input
8            a, b = tee(iterable)
9            # Advance the second iterator by one element
10            next(b, None)
11            # Zip the iterators to create pairs
12            return zip(a, b)
13
14        # Calculate the score by summing the absolute differences between ASCII values of consecutive characters
15        return sum(abs(a - b) for a, b in pairwise(map(ord, s)))
16

1class Solution {
2    public int scoreOfString(String s) {
3        int score = 0; // Initialize the score to zero
4      
5        // Iterate over the string starting from the second character
6        for (int i = 1; i < s.length(); ++i) {
7            // Calculate the absolute difference in ASCII values between consecutive characters and add to the score
8            score += Math.abs(s.charAt(i - 1) - s.charAt(i));
9        }
10      
11        return score; // Return the final score
12    }
13}
14

1#include <string>
2#include <cmath>  // Include the cmath library for the abs() function
3
4class Solution {
5public:
6    int scoreOfString(std::string s) {
7        int ans = 0;
8      
9        // Iterate through the string starting from the second character
10        for (int i = 1; i < s.size(); ++i) {
11            // Calculate the absolute difference between consecutive characters
12            ans += std::abs(s[i] - s[i - 1]);
13        }
14      
15        // Return the total score based on differences
16        return ans;
17    }
18};
19

1// Function to calculate the 'score' of a given string based on ASCII differences
2function scoreOfString(s: string): number {
3    // Initialize the score accumulator
4    let ans = 0;
5
6    // Iterate over the string, starting from the second character
7    for (let i = 1; i < s.length; ++i) {
8        // Calculate the absolute difference between ASCII values of consecutive characters
9        ans += Math.abs(s.charCodeAt(i) - s.charCodeAt(i - 1));
10    }
11
12    // Return the accumulated score
13    return ans;
14}
15

Time and Space Complexity

The provided code first maps each character in the string s to its ASCII value using map(ord, s). This step runs in O(n) time complexity, where n is the length of the string, because it processes each character once.

Then, it uses pairwise to generate consecutive pairs of ASCII values, which can also be done in O(n) time, since it involves accessing each consecutive pair once.

Finally, the code computes the sum of absolute differences of these consecutive pairs. This requires another O(n) pass through the pairs, making the sum calculation also O(n).

Overall, the time complexity of the function is O(n) since all steps are linear, and they occur sequentially.

For space complexity, mapping ord on s writes the ASCII values into a temporary list, which would be O(n). However, if pairwise and the subsequent operations work in a streaming manner without retaining the list, the additional space complexity could be O(1).

If we assume a space-efficient implementation where no additional list storage is needed, the space complexity is O(1). Otherwise, it could be O(n). Given the original reference answer states space complexity as O(1), we assume a space-efficient implementation.

Therefore, the overall time complexity is O(n), and the space complexity is O(1).

Learn more about how to find time and space complexity quickly.

Discover Your Strengths and Weaknesses: Take Our 2-Minute Quiz to Tailor Your Study Plan: