# Solving Leetcode Interviews in Seconds with AI: Total Appeal of A String


	# Introduction
	In this blog post, we will explore how to solve the LeetCode problem "2262" using AI. LeetCode is a popular platform for preparing for coding interviews, and with the help of AI tools like [Chatmagic](https://www.chatmagic.app), we can generate solutions quickly and efficiently - helping you pass the interviews and get the job offer without having to study for months.

	# Problem Statement
	> The appeal of a string is the number of distinct characters found in the string.  For example, the appeal of "abbca" is 3 because it has 3 distinct characters: 'a', 'b', and 'c'.  Given a string s, return the total appeal of all of its substrings. A substring is a contiguous sequence of characters within a string.   Example 1:  Input: s = "abbca" Output: 28 Explanation: The following are the substrings of "abbca": - Substrings of length 1: "a", "b", "b", "c", "a" have an appeal of 1, 1, 1, 1, and 1 respectively. The sum is 5. - Substrings of length 2: "ab", "bb", "bc", "ca" have an appeal of 2, 1, 2, and 2 respectively. The sum is 7. - Substrings of length 3: "abb", "bbc", "bca" have an appeal of 2, 2, and 3 respectively. The sum is 7. - Substrings of length 4: "abbc", "bbca" have an appeal of 3 and 3 respectively. The sum is 6. - Substrings of length 5: "abbca" has an appeal of 3. The sum is 3. The total sum is 5 + 7 + 7 + 6 + 3 = 28.  Example 2:  Input: s = "code" Output: 20 Explanation: The following are the substrings of "code": - Substrings of length 1: "c", "o", "d", "e" have an appeal of 1, 1, 1, and 1 respectively. The sum is 4. - Substrings of length 2: "co", "od", "de" have an appeal of 2, 2, and 2 respectively. The sum is 6. - Substrings of length 3: "cod", "ode" have an appeal of 3 and 3 respectively. The sum is 6. - Substrings of length 4: "code" has an appeal of 4. The sum is 4. The total sum is 4 + 6 + 6 + 4 = 20.    Constraints:  1 <= s.length <= 105 s consists of lowercase English letters.  

	# Explanation
	Here's a breakdown of the problem and an efficient solution:

*   **Key Idea:** The core idea is to iterate through the string and for each character, calculate its contribution to the total appeal. A character contributes to the appeal of a substring if it's the *first* occurrence of that character within that substring. Instead of generating all substrings, we can efficiently calculate this contribution by tracking the last occurrence of each character.

*   **Optimization:** The contribution of character `s[i]` to the total appeal is the number of substrings ending at `i` where `s[i]` is a distinct character. This is `i - last_occurrence[s[i]]`, where `last_occurrence[s[i]]` stores the index of the last time `s[i]` appeared. This allows us to avoid redundant calculations.

*   **Complexity:**
    *   Runtime: O(n), where n is the length of the string.
    *   Storage: O(1), as we use a fixed-size array (26 elements) to store the last occurrence of each lowercase letter.

	
	# Code
	```python
	def appealSum(s: str) -> int:
    """
    Calculates the total appeal of all substrings of a given string.

    Args:
        s: The input string consisting of lowercase English letters.

    Returns:
        The total appeal of all substrings.
    """

    last_occurrence = [-1] * 26  # Store the last occurrence of each character
    total_appeal = 0
    n = len(s)

    for i in range(n):
        char_index = ord(s[i]) - ord('a')
        total_appeal += (i - last_occurrence[char_index]) * (n - i)
        last_occurrence[char_index] = i

    return total_appeal
	```