Reverse Degree of a String - Practice Coding Problems

Reverse Degree of a String - Problem

String Simulation Easy

You're given a string s consisting of lowercase English letters, and your task is to calculate its reverse degree - a unique numerical fingerprint of the string.

The reverse degree calculation works as follows:

For each character in the string, find its reverse alphabet position: 'a' = 26, 'b' = 25, 'c' = 24, ..., 'z' = 1
Multiply this reverse position by the character's 1-indexed position in the string
Sum all these products to get the final reverse degree

Example: For string "abc":

'a' at position 1: 26 × 1 = 26
'b' at position 2: 25 × 2 = 50
'c' at position 3: 24 × 3 = 72
Reverse degree = 26 + 50 + 72 = 148

This problem tests your ability to work with string indexing and character manipulation - fundamental skills for many coding interviews!

Input & Output

example_1.py — Basic String

$ Input: s = "abc"

› Output: 148

💡 Note: For 'a' at position 1: 26 × 1 = 26. For 'b' at position 2: 25 × 2 = 50. For 'c' at position 3: 24 × 3 = 72. Total: 26 + 50 + 72 = 148.

example_2.py — Single Character

$ Input: s = "z"

› Output: 1

💡 Note: For 'z' at position 1: reverse alphabet position is 1, so 1 × 1 = 1.

example_3.py — Repeated Characters

$ Input: s = "aa"

› Output: 78

💡 Note: First 'a' at position 1: 26 × 1 = 26. Second 'a' at position 2: 26 × 2 = 52. Total: 26 + 52 = 78.

Constraints

1 ≤ s.length ≤ 1000
s consists of lowercase English letters only
No empty strings - minimum length is 1

Visualization

Tap to expand

Understanding the Visualization

Assign Danger Values

Each letter gets a danger value: 'a'=26 (most dangerous), 'b'=25, ..., 'z'=1 (least dangerous)

Calculate Position Importance

Each position in the string has increasing importance: position 1, position 2, position 3, etc.

Compute Individual Scores

For each character: multiply its danger value by its position importance

Sum All Scores

Add up all individual character scores to get the total reverse degree

Key Takeaway

🎯 Key Insight: We can calculate each character's reverse alphabet position directly using the formula 27 - (char - 'a' + 1), avoiding any lookup tables or complex calculations.

Asked in

G Google 15 a Amazon 12 ⊞ Microsoft 8 f Meta 6

The optimal solution uses a single pass through the string, calculating each character's contribution using the formula: reverse_alphabet_position × string_position. The reverse alphabet position is computed as 27 - (character - 'a' + 1), giving us O(n) time and O(1) space complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Direct Calculation (Optimal for this problem)	O(n)	O(1)	Iterate through string once, calculate reverse alphabet position and multiply by position

Direct Calculation (Optimal for this problem) — Algorithm Steps

Initialize result variable to 0
Iterate through each character in the string with its index
Calculate reverse alphabet position: 27 - (ord(char) - ord('a') + 1)
Multiply by 1-indexed position in string
Add to running total
Return final sum

Visualization

Tap to expand

Step-by-Step Walkthrough

Start with first character

Calculate reverse alphabet position and multiply by string position

Process each subsequent character

Continue the same calculation for each position

Sum all contributions

Add each character's contribution to get final result

Code -

solution.c — C

#include <stdio.h>
#include <string.h>

int reverseDegree(char* s) {
    int result = 0;
    int len = strlen(s);
    for (int i = 0; i < len; i++) {
        // Calculate reverse alphabet position: a=26, b=25, ..., z=1
        int reversePos = 27 - (s[i] - 'a' + 1);
        // Multiply by 1-indexed position in string
        int stringPos = i + 1;
        result += reversePos * stringPos;
    }
    return result;
}

int main() {
    char s[1001];
    fgets(s, sizeof(s), stdin);
    // Remove newline and quotes
    int len = strlen(s);
    if (s[len-1] == '\n') s[len-1] = '\0';
    if (s[0] == '"') {
        memmove(s, s+1, len-1);
        s[strlen(s)-1] = '\0';
    }
    printf("%d\n", reverseDegree(s));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

We visit each character exactly once, performing constant time operations

✓ Linear Growth

Space Complexity

O(1)

Only using a constant amount of extra space for variables

✓ Linear Space

38.2K Views

Medium Frequency

~8 min Avg. Time

1.5K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Direct Calculation (Optimal for this problem) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler