Leetcode problem 93 - Reverse Prefix of Word

Given a 0-indexed string word and a character ch, reverse the segment of word that starts at index 0 and ends at the index of the first occurrence of ch (inclusive). If the character ch does not exist in word, do nothing.

For example, if word = “abcdefd” and ch = “d”, then you should reverse the segment that starts at 0 and ends at 3 (inclusive). The resulting string will be “dcbaefd”. Return the resulting string.

Example 1:

Input: word = “abcdefd”, ch = “d” Output: “dcbaefd” Explanation: The first occurrence of “d” is at index 3. Reverse the part of word from 0 to 3 (inclusive), the resulting string is “dcbaefd”. Example 2:

Input: word = “xyxzxe”, ch = “z” Output: “zxyxxe” Explanation: The first and only occurrence of “z” is at index 3. Reverse the part of word from 0 to 3 (inclusive), the resulting string is “zxyxxe”. Example 3:

Input: word = “abcd”, ch = “z” Output: “abcd” Explanation: “z” does not exist in word. You should not do any reverse operation, the resulting string is “abcd”.

Constraints:

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

/**
 * @param {string} word - The input word
 * @param {character} ch - The character to find and reverse the prefix up to
 * @return {string} - The word with the prefix reversed up to the first occurrence of ch
 */
var reversePrefix = function (word, ch) {
  // Convert the input word into an array of characters
  let result = word.split("");

  // Find the index of the specified character in the array
  let indexOfCh = result.indexOf(ch);

  // Initialize two pointers for reversing the prefix
  let left = 0;
  let right = indexOfCh;

  // Reverse the portion of the array before and including the first occurrence of ch
  while (left < right) {
    // Swap characters at left and right positions
    let temp = result[left];
    result[left] = result[right];
    result[right] = temp;

    // Move the pointers towards the center
    left++;
    right--;
  }

  // Join the array back into a string and return the result
  return result.join("");
};

Time Complexity: The time complexity of this algorithm is O(n), where n is the length of the input word. The algorithm iterates through the array once, and the reversing process takes linear time.

Space Complexity: The space complexity is O(n), as the algorithm uses an array of characters (result) with the same length as the input word.