Adding Spaces to a String

class Solution {
public:
    string insertSpaces(string str, vector<int>& indices) {
        string outputString;
        outputString.reserve(str.length() + indices.size());
    
        int idx = 0;
        for (int i = 0; i < str.length(); ++i) {
            if (idx < indices.size() && i == indices[idx]) {
                outputString += ' ';
                ++idx;
            }
            outputString += str[i];
        }
    
        return outputString;
    }
};

The solution presented here is a C++ function designed to add spaces into a string at specified indices. The function insertSpaces takes two parameters: the original string str and a vector indices which holds the positions in the string where spaces should be inserted.

To summarize the steps in the function:

1. An empty string outputString is created to build the resultant string, and its capacity is pre-allocated to the sum of the length of str and the size of indices for efficiency.
2. A loop iterates over each character of the string str.
3. Within the loop, a check determines if a space needs to be inserted at the current position (if the current loop index matches the next index in the indices vector).
4. If a space is required, it is appended to outputString before the current character from str.
5. Each character from the original string is then appended to outputString.
6. After traversing all characters in str, the modified string with the inserted spaces is returned.

This function effectively manages string manipulations by using space insertion based on index matching, ensuring that the original string order is maintained while integrating the required spaces.

class Solution {
    
    public String insertSpaces(String str, int[] positions) {
        StringBuilder output = new StringBuilder();
        output.ensureCapacity(str.length() + positions.length);
    
        int idx = 0;
        for (int pos = 0; pos < str.length(); ++pos) {
            if (idx < positions.length && pos == positions[idx]) {
                output.append(' ');
                ++idx;
            }
            output.append(str.charAt(pos));
        }
    
        return output.toString();
    }
}

The provided Java solution involves a method insertSpaces that integrates spaces into a given string based on specified positions. The function accepts two parameters: a string str and an array of integers positions which indicates where spaces should be inserted within the string.

Ensure you understand these steps for comprehension:

1. Initialize a StringBuilder named output to build the final string with spaces. This is more efficient than using a regular string since strings are immutable in Java, which means every modification creates a new string.
2. Set the initial capacity of StringBuilder to accommodate both the original string's length and the number of spaces to be inserted, ensuring no reallocation is needed during construction.
3. Use a for-loop to iterate over each character of the input string by index pos.
4. Within the loop, check if the current position matches the next position in the positions array where a space should be inserted.
5. If a match is found, append a space to output and increment the index idx that tracks positions in the positions array.
6. Append the current character of str to output.
7. Continue this process until all characters from the original string are processed.
8. Return the string built by output which now includes the inserted spaces according to the specified positions.

By following these steps, the method efficiently augments the original string with spaces at the correct positions, resulting in the desired formatted output.

class Solution:
    def insertSpaces(self, text: str, positions: List[int]) -> str:
        output = []
        # Adjust size initially to optimize memory usage
        output = [None] * (len(text) + len(positions))
    
        posIdx = 0
        txtIdx = 0
    
        for idx in range(len(text)):
            if posIdx < len(positions) and idx == positions[posIdx]:
                # Place space in specified position
                output[txtIdx] = " "
                txtIdx += 1
                posIdx += 1
    
            # Place current character from the text
            output[txtIdx] = text[idx]
            txtIdx += 1
    
        # Combine the list into a string and trim unnecessary parts
        return "".join(output[:txtIdx])

In the given Python solution for adding spaces to specific positions in a string, the Solution class defines the method insertSpaces which accomplishes the task efficiently and effectively.

• The function insertSpaces takes two parameters:

  • text: The string to which spaces will be added.
  • positions: A list of integers indicating the indices in the string where spaces should be inserted.

• The method starts by initializing an empty list output with a size predetermined by the length of the input string and the number of spaces to be inserted. This optimized space allocation prevents constant resizing during the loop execution and helps optimize memory usage.

• Two index variables, posIdx and txtIdx, are initialized to zero. These indices track the positions within positions and the output list, respectively.

Inside the loop which iterates over each character of the input string:

• If the current position matches an entry in positions (and posIdx is within range), a space is inserted into the output list at the current text index (txtIdx), and both txtIdx and posIdx are incremented.

• Regardless of whether a space is added, the current character of text is always placed into the output list, and txtIdx is incremented.

After the loop, the parts of the output list that were used are joined to form the result string. Potential unused parts of the list are excluded by slicing output up to txtIdx.

This solution is efficient in terms of both time and space complexity, making it well-suited for handling large strings and numerous positions for space insertion.