Reverse Prefix of Word - Practice Coding Problems

Reverse Prefix of Word - Problem

You're given a string word and a target character ch. Your task is to reverse the prefix of the string that starts from the beginning and ends at the first occurrence of the target character.

Think of it like finding a bookmark in a book - once you find the first occurrence of your target character, you need to reverse everything from the start up to and including that character. If the character doesn't exist in the string, leave it unchanged.

Example:

Input: word = "abcdefd", ch = "d"
The first 'd' is at index 3
Reverse the prefix "abcd" → "dcba"
Result: "dcbaefd"

This problem tests your understanding of string manipulation, character searching, and in-place reversal techniques.

Input & Output

example_1.py — Basic Case

$ Input: word = "abcdefd", ch = "d"

› Output: "dcbaefd"

💡 Note: The first occurrence of 'd' is at index 3. We reverse the prefix "abcd" to get "dcba", then append the remaining "efd" to get "dcbaefd".

example_2.py — Character Not Found

$ Input: word = "xyxzxe", ch = "z"

› Output: "zxyxxe"

💡 Note: The first occurrence of 'z' is at index 3. We reverse the prefix "xyxz" to get "zxyx", then append the remaining "xe" to get "zxyxxe".

example_3.py — Character Not Present

$ Input: word = "abcd", ch = "z"

› Output: "abcd"

💡 Note: Since 'z' doesn't exist in the string "abcd", we return the original string unchanged.

Constraints

1 ≤ word.length ≤ 250
word consists of lowercase English letters
ch is a lowercase English letter

Visualization

Tap to expand

Understanding the Visualization

Find the Bookmark

Scan through the pages to find where the bookmark (target character) is located

Mark the Boundaries

Place your left hand at the beginning and right hand at the bookmark position

Flip Pages

Swap pages from both hands, moving your hands closer to each other

Complete the Flip

Continue until your hands meet - the prefix is now reversed!

Key Takeaway

🎯 Key Insight: Use two pointers to efficiently reverse the prefix in-place, eliminating the need for extra space while maintaining optimal time complexity.

Asked in

a Amazon 25 ⊞ Microsoft 18 G Google 15 f Facebook 12

The optimal solution uses the two-pointers technique to reverse the prefix in-place. First, find the target character using built-in string methods like find() or indexOf(). Then, use two pointers starting from both ends of the prefix and swap characters while moving toward the center. This achieves O(n) time complexity and O(1) extra space in languages with mutable strings.

Common Approaches

Approach	Time	Space	Notes
✓ Two Pointers (Optimal In-Place)	O(n)	O(1) or O(n)	Find the target character, then use two pointers to reverse the prefix in-place
Brute Force (String Concatenation)	O(n)	O(n)	Find the character, then reverse by building a new string character by character

Two Pointers (Optimal In-Place) — Algorithm Steps

Find the first occurrence of the target character
If not found, return the original string
Convert string to mutable array (for languages that support it)
Use two pointers: left at index 0, right at the found index
Swap characters at left and right positions, move pointers toward center
Continue until left >= right
Convert back to string and return

Visualization

Tap to expand

Step-by-Step Walkthrough

Find Target

Locate target character 'd' at index 3, this defines our prefix boundary

Initialize Pointers

Set left pointer at index 0 ('a') and right pointer at index 3 ('d')

Swap & Move

Swap characters at left/right positions, then move pointers inward

Continue

Repeat swapping until pointers meet in the middle

Code -

solution.c — C

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

char* reversePrefix(char* word, char ch) {
    int len = strlen(word);
    
    // Find the first occurrence of ch
    int index = -1;
    for (int i = 0; i < len; i++) {
        if (word[i] == ch) {
            index = i;
            break;
        }
    }
    
    // If character not found, return copy of original string
    if (index == -1) {
        char* result = (char*)malloc((len + 1) * sizeof(char));
        strcpy(result, word);
        return result;
    }
    
    // Create a copy to modify
    char* result = (char*)malloc((len + 1) * sizeof(char));
    strcpy(result, word);
    
    // Use two pointers to reverse the prefix
    int left = 0, right = index;
    while (left < right) {
        char temp = result[left];
        result[left] = result[right];
        result[right] = temp;
        left++;
        right--;
    }
    
    return result;
}

int main() {
    char word[1000], ch_str[10];
    fgets(word, sizeof(word), stdin);
    fgets(ch_str, sizeof(ch_str), stdin);
    
    // Remove newlines and quotes
    word[strcspn(word, "\n")] = 0;
    ch_str[strcspn(ch_str, "\n")] = 0;
    
    if (word[0] == '"') {
        memmove(word, word + 1, strlen(word));
        word[strlen(word) - 1] = '\0';
    }
    if (ch_str[0] == '"') {
        memmove(ch_str, ch_str + 1, strlen(ch_str));
        ch_str[strlen(ch_str) - 1] = '\0';
    }
    
    char ch = ch_str[0];
    char* result = reversePrefix(word, ch);
    printf("\"%s\"\n", result);
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

We scan the string once to find the character O(n) and reverse the prefix in O(k) where k is the prefix length, giving us O(n) overall

✓ Linear Growth

Space Complexity

O(1) or O(n)

O(1) in languages with mutable strings like C++, O(n) in languages with immutable strings like Python where we need to convert to list

⚡ Linearithmic Space

47.0K Views

Medium Frequency

~8 min Avg. Time

1.9K 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

Two Pointers (Optimal In-Place) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler