Jobs

Interviews

Discussions

Reverse Degree of a String #2 Most Asked

Easy

Capgemini

1 view

Topics:

Strings

Given a string s, calculate its reverse degree.

The reverse degree is calculated as follows:

For each character, multiply its position in the reversed alphabet ('a' = 26, 'b' = 25, ..., 'z' = 1) with its position in the string (1-indexed).
Sum these products for all characters in the string.

Return the reverse degree of s.

Example 1:

Input: s = "abc"

Output: 148

Explanation:

Letter	Index in Reversed Alphabet	Index in String	Product
`'a'`	26	1	26
`'b'`	25	2	50
`'c'`	24	3	72

The reversed degree is 26 + 50 + 72 = 148.

Example 2:

Input: s = "zaza"

Output: 160

Explanation:

Letter	Index in Reversed Alphabet	Index in String	Product
`'z'`	1	1	1
`'a'`	26	2	52
`'z'`	1	3	3
`'a'`	26	4	104

The reverse degree is 1 + 52 + 3 + 104 = 160.

Constraints:

1 <= s.length <= 1000
s contains only lowercase English letters.

Try coding it in LeetCode

Reverse Degree of a String #2 Most Asked

Easy

Capgemini

1 view

Topics:

Strings

Given a string s, calculate its reverse degree.

The reverse degree is calculated as follows:

For each character, multiply its position in the reversed alphabet ('a' = 26, 'b' = 25, ..., 'z' = 1) with its position in the string (1-indexed).
Sum these products for all characters in the string.

Return the reverse degree of s.

Example 1:

Input: s = "abc"

Output: 148

Explanation:

Letter	Index in Reversed Alphabet	Index in String	Product
`'a'`	26	1	26
`'b'`	25	2	50
`'c'`	24	3	72

The reversed degree is 26 + 50 + 72 = 148.

Example 2:

Input: s = "zaza"

Output: 160

Explanation:

Letter	Index in Reversed Alphabet	Index in String	Product
`'z'`	1	1	1
`'a'`	26	2	52
`'z'`	1	3	3
`'a'`	26	4	104

The reverse degree is 1 + 52 + 3 + 104 = 160.

Constraints:

1 <= s.length <= 1000
s contains only lowercase English letters.

Try coding it in LeetCode

Solution

Clarifying Questions

When you get asked this question in a real-life environment, it will often be ambiguous (especially at FAANG). Make sure to ask these questions in that case:

What should be the expected output for an empty string or a string with only one character?
Does the input string contain only alphabetical characters, or should I handle numbers, symbols, or whitespace?
When comparing characters for reverse alphabetical order, should 'a' and 'z' be considered neighbors in a wrap-around fashion?
How should I handle non-alphabetic characters if they are adjacent to an alphabetic character, for example in the string 'c#b'?
What are the constraints on the length of the input string?

Brute Force Solution

Approach

The problem asks us to find the shortest piece of text that contains all the letters of a given word, in any order. The brute force approach involves checking every possible substring of the original text, one by one, to see if it contains all the required letters.

Here's how the algorithm would work step-by-step:

First, we look at the special word to figure out which letters we need and how many of each are required. This gives us a checklist of letters to find.
Then, we look at all possible continuous sections of the main text. We start with the very small sections, just one letter long.
For each section, we check if it contains all the letters from our checklist. We can do this by making a new checklist for that section and comparing it to our original one.
If a section has all the needed letters, we remember how long it is.
We keep doing this for every single possible section of the text, from the shortest to the longest.
After checking every single section, we will have a collection of lengths from all the sections that worked.
Finally, we simply choose the smallest length from our collection. This is the length of the shortest piece of text that satisfies the condition.

Code Implementation

from collections import Counter

def reverse_degree_brute_force(text, word):
    # This map holds the counts of each character required by the word.
    required_characters_map = Counter(word)

    number_of_characters_in_text = len(text)
    shortest_valid_length = float('inf')

    # We must check every single possible substring of the text.
    for start_index in range(number_of_characters_in_text):
        for end_index in range(start_index, number_of_characters_in_text):
            current_substring = text[start_index : end_index + 1]
            substring_character_map = Counter(current_substring)

            is_valid_substring = True
            # A substring is valid only if it contains at least as many of each required character as the word.
            for character, required_count in required_characters_map.items():
                if substring_character_map.get(character, 0) < required_count:
                    is_valid_substring = False
                    break

            if is_valid_substring:
                current_length = len(current_substring)
                # We track the minimum length found among all valid substrings.
                if current_length < shortest_valid_length:
                    shortest_valid_length = current_length
    
    return shortest_valid_length if shortest_valid_length != float('inf') else -1

Big(O) Analysis

Time Complexity

O(n^2 * m) – The dominant cost comes from iterating through all possible substrings of the main text, of which there are approximately n^2/2 where n is the length of the text. For each of these n^2 substrings, we must validate if it contains all the required letters from the special word. This validation step involves creating a frequency map for the substring and comparing it to the word's frequency map, taking a time proportional to the substring's length, which is at most n. A more precise upper bound for the validation is the size of the special word's alphabet, let's call it m. Therefore, the total operations are driven by checking every substring against the word's character requirements. This results in a complexity of roughly n * n * m operations, which simplifies to O(n^2 * m).

Space Complexity

O(K) – The primary auxiliary space is used for the checklist of required letters from the special word. This checklist, implemented as a hash map or an array, stores a count for each unique character. If the special word has K unique characters, the space required for this checklist is proportional to K. During the check for each substring, another temporary checklist of the same maximum size is created, but this does not change the overall space complexity, which remains independent of the main text's length.

Optimal Solution

Approach

The goal is to find the smallest possible section of the text that contains at least one of every character. We can achieve this efficiently by expanding a window from the left until it has all the needed characters, then shrinking it from the left as much as possible while keeping all the characters inside.

Here's how the algorithm would work step-by-step:

First, figure out all the unique characters that exist in the entire string. This gives us a target set of characters we need to find.
Imagine a 'window' that can slide over the text. Start this window at the very beginning of the string.
Start expanding the right side of this window, one character at a time, until the text inside the window contains at least one of every unique character from our target set.
Once the window has everything we need, we've found a potential solution. Now, we try to make it smaller.
Start shrinking the window from its left side, one character at a time. Keep shrinking as long as the window still contains all the necessary unique characters.
Stop shrinking as soon as removing one more character from the left would cause us to lose one of the required unique characters.
At this point, you have the smallest possible window that starts at that specific position. Take note of its size.
To find the absolute smallest window, continue this process: move the window's starting point forward one spot and repeat the expand-and-shrink process until you've checked all possible starting points in the text.
After checking all possibilities, the smallest window size you noted is the final answer.

Code Implementation

def reverse_degree_of_string(text):
    # First, determine the set of all unique characters that must be in our window.

    target_characters = set(text)
    number_of_target_characters = len(target_characters)

    if number_of_target_characters == 0:
        return 0

    left_pointer = 0
    characters_in_window_counts = {}
    characters_formed_in_window = 0
    min_length_found = float('inf')

    for right_pointer, current_character in enumerate(text):
        characters_in_window_counts[current_character] = characters_in_window_counts.get(current_character, 0) + 1
        
        # When a character's count becomes 1, it means we have just satisfied one of the target characters.

        if characters_in_window_counts[current_character] == 1:
            characters_formed_in_window += 1

        # Once the window is valid (contains all unique characters), we try to shrink it from the left.

        while left_pointer <= right_pointer and characters_formed_in_window == number_of_target_characters:
            current_window_length = right_pointer - left_pointer + 1
            min_length_found = min(min_length_found, current_window_length)

            left_character = text[left_pointer]
            characters_in_window_counts[left_character] -= 1

            # If removing the left character makes the window invalid, we must stop shrinking for this round.

            if characters_in_window_counts[left_character] == 0:
                characters_formed_in_window -= 1

            left_pointer += 1
    
    return min_length_found if min_length_found != float('inf') else 0

Big(O) Analysis

Time Complexity

O(n) – The time complexity is determined by the sliding window approach, where two pointers, representing the left and right sides of the window, traverse the string. The right pointer moves forward from beginning to end, visiting each character once. The left pointer also moves forward, potentially visiting each character once as the window shrinks. Since each character in the string is visited at most twice (once by the right pointer and once by the left), the total number of operations is proportional to n, the length of the string. This linear traversal results in a time complexity of O(n).

Space Complexity

O(C) – The space complexity is determined by the data structures used to track characters. We need one data structure, likely a hash map or set, to store the set of all unique characters in the input string, which requires space proportional to the number of unique characters, C. A second hash map is used for the sliding window to count the characters currently inside it, which also stores at most C unique characters. Since the size of the character set is typically a fixed constant (like 26 for lowercase English letters or 256 for ASCII), this can be considered O(1) constant space.

Edge Cases

Case	How to Handle
Input string is null or empty	The function should return 0 as there are no adjacent pairs to evaluate.
Input string has only one character	The function should return 0 since a single character cannot form a pair.
String contains non-alphabetic characters like numbers, symbols, or spaces	These characters should be ignored, and only pairs of adjacent alphabetic characters should be considered for the count.
An adjacent pair consists of the same letter with different cases (e.g., 'aA' or 'Bb')	This is not a reverse alphabetical pair, so the count should not be incremented.
String consists of only one repeating character (e.g., 'aaaaa' or 'BBBB')	The function should correctly return 0 as no adjacent characters are reverse alphabetical neighbors.
String has mixed casing for a valid reverse neighbor pair (e.g., 'Cb' or 'zY')	The case-insensitive comparison logic should correctly identify these as valid pairs and increment the count.
String contains letters at the boundaries of the alphabet (e.g., 'ba' or 'zy')	The solution must correctly identify 'b' and 'a' or 'z' and 'y' as reverse alphabetical neighbors.
A very long string that approaches system memory or processing time limits	The solution's linear O(N) time complexity and constant O(1) space complexity ensure it scales efficiently without issues.

Input string is null or empty

How to Handle:

The function should return 0 as there are no adjacent pairs to evaluate.

Input string has only one character

How to Handle:

The function should return 0 since a single character cannot form a pair.

String contains non-alphabetic characters like numbers, symbols, or spaces

How to Handle:

These characters should be ignored, and only pairs of adjacent alphabetic characters should be considered for the count.

An adjacent pair consists of the same letter with different cases (e.g., 'aA' or 'Bb')

How to Handle:

This is not a reverse alphabetical pair, so the count should not be incremented.

String consists of only one repeating character (e.g., 'aaaaa' or 'BBBB')

How to Handle:

The function should correctly return 0 as no adjacent characters are reverse alphabetical neighbors.

String has mixed casing for a valid reverse neighbor pair (e.g., 'Cb' or 'zY')

How to Handle:

The case-insensitive comparison logic should correctly identify these as valid pairs and increment the count.

String contains letters at the boundaries of the alphabet (e.g., 'ba' or 'zy')

How to Handle:

The solution must correctly identify 'b' and 'a' or 'z' and 'y' as reverse alphabetical neighbors.

A very long string that approaches system memory or processing time limits

How to Handle:

The solution's linear O(N) time complexity and constant O(1) space complexity ensure it scales efficiently without issues.

Solution

Clarifying Questions

When you get asked this question in a real-life environment, it will often be ambiguous (especially at FAANG). Make sure to ask these questions in that case:

What should be the expected output for an empty string or a string with only one character?
Does the input string contain only alphabetical characters, or should I handle numbers, symbols, or whitespace?
When comparing characters for reverse alphabetical order, should 'a' and 'z' be considered neighbors in a wrap-around fashion?
How should I handle non-alphabetic characters if they are adjacent to an alphabetic character, for example in the string 'c#b'?
What are the constraints on the length of the input string?

Brute Force Solution

Approach

Here's how the algorithm would work step-by-step:

First, we look at the special word to figure out which letters we need and how many of each are required. This gives us a checklist of letters to find.
Then, we look at all possible continuous sections of the main text. We start with the very small sections, just one letter long.
For each section, we check if it contains all the letters from our checklist. We can do this by making a new checklist for that section and comparing it to our original one.
If a section has all the needed letters, we remember how long it is.
We keep doing this for every single possible section of the text, from the shortest to the longest.
After checking every single section, we will have a collection of lengths from all the sections that worked.
Finally, we simply choose the smallest length from our collection. This is the length of the shortest piece of text that satisfies the condition.

Code Implementation

from collections import Counter

def reverse_degree_brute_force(text, word):
    # This map holds the counts of each character required by the word.
    required_characters_map = Counter(word)

    number_of_characters_in_text = len(text)
    shortest_valid_length = float('inf')

    # We must check every single possible substring of the text.
    for start_index in range(number_of_characters_in_text):
        for end_index in range(start_index, number_of_characters_in_text):
            current_substring = text[start_index : end_index + 1]
            substring_character_map = Counter(current_substring)

            is_valid_substring = True
            # A substring is valid only if it contains at least as many of each required character as the word.
            for character, required_count in required_characters_map.items():
                if substring_character_map.get(character, 0) < required_count:
                    is_valid_substring = False
                    break

            if is_valid_substring:
                current_length = len(current_substring)
                # We track the minimum length found among all valid substrings.
                if current_length < shortest_valid_length:
                    shortest_valid_length = current_length
    
    return shortest_valid_length if shortest_valid_length != float('inf') else -1

Big(O) Analysis

Time Complexity

Space Complexity

Optimal Solution

Approach

Here's how the algorithm would work step-by-step:

First, figure out all the unique characters that exist in the entire string. This gives us a target set of characters we need to find.
Imagine a 'window' that can slide over the text. Start this window at the very beginning of the string.
Start expanding the right side of this window, one character at a time, until the text inside the window contains at least one of every unique character from our target set.
Once the window has everything we need, we've found a potential solution. Now, we try to make it smaller.
Start shrinking the window from its left side, one character at a time. Keep shrinking as long as the window still contains all the necessary unique characters.
Stop shrinking as soon as removing one more character from the left would cause us to lose one of the required unique characters.
At this point, you have the smallest possible window that starts at that specific position. Take note of its size.
To find the absolute smallest window, continue this process: move the window's starting point forward one spot and repeat the expand-and-shrink process until you've checked all possible starting points in the text.
After checking all possibilities, the smallest window size you noted is the final answer.

Code Implementation

def reverse_degree_of_string(text):
    # First, determine the set of all unique characters that must be in our window.

    target_characters = set(text)
    number_of_target_characters = len(target_characters)

    if number_of_target_characters == 0:
        return 0

    left_pointer = 0
    characters_in_window_counts = {}
    characters_formed_in_window = 0
    min_length_found = float('inf')

    for right_pointer, current_character in enumerate(text):
        characters_in_window_counts[current_character] = characters_in_window_counts.get(current_character, 0) + 1
        
        # When a character's count becomes 1, it means we have just satisfied one of the target characters.

        if characters_in_window_counts[current_character] == 1:
            characters_formed_in_window += 1

        # Once the window is valid (contains all unique characters), we try to shrink it from the left.

        while left_pointer <= right_pointer and characters_formed_in_window == number_of_target_characters:
            current_window_length = right_pointer - left_pointer + 1
            min_length_found = min(min_length_found, current_window_length)

            left_character = text[left_pointer]
            characters_in_window_counts[left_character] -= 1

            # If removing the left character makes the window invalid, we must stop shrinking for this round.

            if characters_in_window_counts[left_character] == 0:
                characters_formed_in_window -= 1

            left_pointer += 1
    
    return min_length_found if min_length_found != float('inf') else 0

Big(O) Analysis

Time Complexity

Space Complexity

Edge Cases

Case	How to Handle
Input string is null or empty	The function should return 0 as there are no adjacent pairs to evaluate.
Input string has only one character	The function should return 0 since a single character cannot form a pair.
String contains non-alphabetic characters like numbers, symbols, or spaces	These characters should be ignored, and only pairs of adjacent alphabetic characters should be considered for the count.
An adjacent pair consists of the same letter with different cases (e.g., 'aA' or 'Bb')	This is not a reverse alphabetical pair, so the count should not be incremented.
String consists of only one repeating character (e.g., 'aaaaa' or 'BBBB')	The function should correctly return 0 as no adjacent characters are reverse alphabetical neighbors.
String has mixed casing for a valid reverse neighbor pair (e.g., 'Cb' or 'zY')	The case-insensitive comparison logic should correctly identify these as valid pairs and increment the count.
String contains letters at the boundaries of the alphabet (e.g., 'ba' or 'zy')	The solution must correctly identify 'b' and 'a' or 'z' and 'y' as reverse alphabetical neighbors.
A very long string that approaches system memory or processing time limits	The solution's linear O(N) time complexity and constant O(1) space complexity ensure it scales efficiently without issues.

Input string is null or empty

How to Handle:

The function should return 0 as there are no adjacent pairs to evaluate.

Input string has only one character

How to Handle:

The function should return 0 since a single character cannot form a pair.

String contains non-alphabetic characters like numbers, symbols, or spaces

How to Handle:

These characters should be ignored, and only pairs of adjacent alphabetic characters should be considered for the count.

An adjacent pair consists of the same letter with different cases (e.g., 'aA' or 'Bb')

How to Handle:

This is not a reverse alphabetical pair, so the count should not be incremented.

String consists of only one repeating character (e.g., 'aaaaa' or 'BBBB')

How to Handle:

The function should correctly return 0 as no adjacent characters are reverse alphabetical neighbors.

String has mixed casing for a valid reverse neighbor pair (e.g., 'Cb' or 'zY')

How to Handle:

The case-insensitive comparison logic should correctly identify these as valid pairs and increment the count.

String contains letters at the boundaries of the alphabet (e.g., 'ba' or 'zy')

How to Handle:

The solution must correctly identify 'b' and 'a' or 'z' and 'y' as reverse alphabetical neighbors.

A very long string that approaches system memory or processing time limits

How to Handle:

The solution's linear O(N) time complexity and constant O(1) space complexity ensure it scales efficiently without issues.

0/0 Capgemini questions completed

0/0 completed