Reverse Prefix of Word

class Solution {
public:
    string reversePrefix(string str, char delimiter) {
        int startIndex = 0;
    
        for (int endIndex = 0; endIndex < str.length(); endIndex++) {
            if (str[endIndex] == delimiter) {
                while (startIndex < endIndex) {
                    swap(str[startIndex], str[endIndex]);
                    startIndex++;
                    endIndex--;
                }
                return str;
            }
        }
        return str;
    }
};

The provided C++ solution is designed to reverse the prefix of a string up until a specified delimiter character. The function reversePrefix, defined within the Solution class, accepts two arguments: a string str and a character delimiter.

Follow these general steps to understand the implementation:

1. Initialize startIndex to 0 to track the beginning of the string.
2. Use a for loop with a variable endIndex iterating over the string to locate the delimiter character.
3. When the delimiter is found, engage a nested loop that swaps characters from startIndex to endIndex, effectively reversing the segment.
4. Increment startIndex and decrement endIndex concurrently within the loop to move towards the center from both ends, ensuring the substring's characters are reversed.
5. Upon completing the reversal or if the delimiter is not found, the modified string is returned.

This function makes a direct modification to the input string and handles the scenario where the delimiter does not exist by returning the string unchanged. The approach is efficient, leveraging in-place character swaps to perform the reversal without needing additional memory for substring manipulation.

public class Solution {
    public String reversePrefix(String str, char delimiter) {
        char[] arr = str.toCharArray();
        int start = 0;
    
        for (int end = 0; end < str.length(); end++) {
            if (arr[end] == delimiter) {
                while (start < end) {
                    charSwap(arr, start, end);
                    start++;
                    end--;
                }
                return new String(arr);
            }
        }
        return str;
    }
    
    private void charSwap(char[] array, int pos1, int pos2) {
        char hold = array[pos2];
        array[pos2] = array[pos1];
        array[pos1] = hold;
    }
}

The provided Java code aims to reverse the prefix of a word up to a specified delimiter character and return the modified string. The method reversePrefix takes two parameters: a string str and a character delimiter. It reverses the sequence of characters in str from the beginning up to the first occurrence of delimiter.

• Steps for Execution:

  1. Convert string str to a character array arr to facilitate character swapping.

  2. Initialize an integer start to track the beginning of the substring to reverse.

  3. Use a loop where end iterates through the characters in arr. Inside the loop, check if the current character matches the delimiter.

  4. If a match is found, use another loop to swap characters from start to end until they meet, effectively reversing the order of characters in that segment.

  5. Return the newly formed string constructed from array arr after the reversal.

• If delimiter is not found in str, the method returns the original string unchanged.

The helper method charSwap aids in swapping characters in the array arr by taking the array itself and two positions (pos1 and pos2) of characters to swap. This method performs the swap by utilizing a temporary placeholder.

Ensure you handle edge cases such as scenarios where:

• The delimiter does not exist in str.
• The delimiter is at the start or end of str.
• The str is empty or contains only one character.

By implementing the above mechanism, this Java solution efficiently handles the task of selectively reversing parts of a string based on a given delimiter.

class Solution:
    def reversePrefix(self, word: str, ch: str) -> str:
        seq = list(word)
        start = 0
    
        for end in range(len(word)):
            if seq[end] == ch:
                while start < end:
                    seq[end], seq[start] = seq[start], seq[end]
                    start += 1
                    end -= 1
                return "".join(seq)
        return word

In the Python solution provided for "Reverse Prefix of Word," a method reversePrefix is implemented within a Solution class. The method takes two parameters: word, a string, and ch, a character. It aims to reverse the portion of word that precedes the first occurrence of ch.

Follow these steps to understand the functionality:

1. Convert the input string word into a list seq to facilitate in-place modifications.
2. Initialize start to 0 to track the beginning of the sequence to reverse.
3. Iterate over the indices (end) of the sequence.
4. Check if the current character matches ch.
5. If a match is found, use a while loop to reverse the segment from start to end:
   • Swap characters at positions start and end.
   • Increment start and decrement end to progressively narrow down the focused segment.
6. Once the segment is reversed, or if ch is not found in word, convert the list back to a string and return it.

This approach efficiently locates and reverses the required segment and then immediately returns the modified word.