3110. Score of a String - Explanation

Problem Link

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.

Return the score of s.

Example 1:

Input: s = "code"

Output: 24

Explanation: The ASCII values of the characters in the given string are: 'c' = 99, 'o' = 111, 'd' = 100, and 'e' = 101. The score of s will be: |111 - 99| + |100 - 111| + |101 - 100|.

Example 2:

Input: s = "neetcode"

Output: 65

Constraints:

• 2 <= s.length <= 100
• s is made up of lowercase English letters.

Topics

String

Company Tags

Please upgrade to NeetCode Pro to view company tags.

Prerequisites

Before attempting this problem, you should be comfortable with:

• String iteration - Traversing through characters in a string using indices
• ASCII values - Converting characters to their numeric ASCII codes for comparison
• Absolute value - Computing the non-negative difference between two numbers

---

1. Iteration

Intuition

The score of a string is defined as the sum of absolute differences between adjacent characters' ASCII values. Since we need to compare each character with its neighbor, we simply walk through the string once, computing the difference between consecutive characters and accumulating the result in res.

Algorithm

1. Initialize a variable res to store the running total.
2. Iterate through the string from index 0 to n - 2:
   • For each position i, compute the absolute difference between the ASCII values of s[i] and s[i + 1].
   • Add this difference to res.
3. Return res as the final answer.

class Solution:
    def scoreOfString(self, s: str) -> int:
        res = 0
        for i in range(len(s) - 1):
            res += abs(ord(s[i]) - ord(s[i + 1]))
        return res

public class Solution {
    public int scoreOfString(String s) {
        int res = 0;
        for (int i = 0; i < s.length() - 1; i++) {
            res += Math.abs(s.charAt(i) - s.charAt(i + 1));
        }
        return res;
    }
}

class Solution {
public:
    int scoreOfString(string s) {
        int res = 0;
        for (int i = 0; i < s.length() - 1; i++) {
            res += abs(s[i] - s[i + 1]);
        }
        return res;
    }
};

class Solution {
    /**
     * @param {string} s
     * @return {number}
     */
    scoreOfString(s) {
        let res = 0;
        for (let i = 0; i < s.length - 1; i++) {
            res += Math.abs(s.charCodeAt(i) - s.charCodeAt(i + 1));
        }
        return res;
    }
}

public class Solution {
    public int ScoreOfString(string s) {
        int res = 0;
        for (int i = 0; i < s.Length - 1; i++) {
            res += Math.Abs(s[i] - s[i + 1]);
        }
        return res;
    }
}

func scoreOfString(s string) int {
    res := 0
    for i := 0; i < len(s)-1; i++ {
        diff := int(s[i]) - int(s[i+1])
        if diff < 0 {
            diff = -diff
        }
        res += diff
    }
    return res
}

class Solution {
    fun scoreOfString(s: String): Int {
        var res = 0
        for (i in 0 until s.length - 1) {
            res += kotlin.math.abs(s[i].code - s[i + 1].code)
        }
        return res
    }
}

class Solution {
    func scoreOfString(_ s: String) -> Int {
        let chars = Array(s)
        var res = 0
        for i in 0..<chars.count - 1 {
            res += abs(Int(chars[i].asciiValue!) - Int(chars[i + 1].asciiValue!))
        }
        return res
    }
}

Time & Space Complexity

• Time complexity: $O(n)$
• Space complexity: $O(1)$

Common Pitfalls

Off-by-One Error in Loop Bounds

A frequent mistake is iterating to n instead of n - 1, causing an index out of bounds error when accessing s[i + 1]. Since you compare adjacent pairs, the loop should run from 0 to len(s) - 2 inclusive, processing n - 1 pairs for a string of length n.

Forgetting Absolute Value

Some solutions subtract ASCII values without taking the absolute value, resulting in negative contributions to the score. The problem requires the sum of absolute differences, so always wrap the subtraction with abs() to handle cases where s[i] > s[i + 1].