### Introduction
You are given a sentence consisting of words separated by spaces. Your task is to write a function that reverses the order of words in the sentence. The function should return the sentence with the words in reversed order, while maintaining the original spacing and word content.

### Requirements
1. **Function Signature**: Implement the function `reverseWords` that takes one parameter:
   - `sentence`: A string containing the sentence to be reversed.

2. **Output**: The function should return a new string with the words in the sentence reversed in order.

### Example
Consider the following input sentence:

```javascript
let sentence = "I love javascript";
```

**Expected Output**:
```javascript
"javascript love I"
```

### Constraints
- The function should have a time complexity of O(N), where N is the length of the input sentence.
- The function should use O(1) additional space.

### Function Signature
```javascript
function reverseWords(sentence) {
    // implementation here
}
```

### Explanation
1. **Reversing the Entire Sentence**: First, reverse the entire sentence.
2. **Reversing Individual Words**: Then, reverse each word in the reversed sentence to restore the original word order within the reversed sentence.

### Example Walkthrough
For the input sentence `"I love javascript"`:
1. Reverse the entire sentence: `"tpircsavaj evol I"`
2. Reverse each word in the reversed sentence to get the final result:
   - Reverse `"tpircsavaj"` to `"javascript"`
   - Reverse `"evol"` to `"love"`
   - Reverse `"I"` to `"I"`
3. The final output is `"javascript love I"`

### Algorithm
1. **Initial Reversal**: Use the `split`, `reverse`, and `join` methods to reverse the entire sentence.
2. **Word Reversal**: Use two pointers to identify the boundaries of each word and reverse the characters within those boundaries.
3. **Return Result**: Return the modified sentence.

This approach ensures that the function operates in O(N) time complexity and uses O(1) additional space, meeting the problem's constraints.

complete.test.js

index.js

partial.test.js

Reverse words in a sentence

### Introduction
Reversing the order of words in a sentence is a common problem in string manipulation. The challenge is to reverse the words while preserving their original content and spacing. This editorial will explain the approach to solve this problem, including the reasoning behind the algorithm and its implementation details.

### Problem Restatement
Given a sentence consisting of words separated by spaces, the task is to write a function `reverseWords` that reverses the order of words in the sentence. The function should return a new string with the words in reversed order, while maintaining the original spacing and word content.

### Example
Consider the following input sentence:

```javascript
let sentence = "I love javascript";
```

**Expected Output**:
```javascript
"javascript love I"
```

### Constraints
- The function should have a time complexity of O(N), where N is the length of the input sentence.
- The function should use O(1) additional space.

### Solution Approach

### 1. Understanding the Problem
To solve this problem, we need to reverse the entire sentence first and then reverse each word within the reversed sentence to restore the original word order but in the reversed sentence.

### 2. Algorithm Steps
1. **Reverse the Entire Sentence**: Use the `split`, `reverse`, and `join` methods to reverse the entire sentence.
2. **Reverse Each Word**: Use two pointers to identify the boundaries of each word and reverse the characters within those boundaries.

### 3. Detailed Steps
1. **Initial Reversal**: Convert the sentence into an array of characters, reverse the array, and join it back into a string. This step reverses the entire sentence.
2. **Word Reversal**: Use two pointers, `left` and `right`, to identify the start and end of each word within the reversed sentence. For each word, reverse the characters between the `left` and `right` pointers.
3. **Return Result**: Return the modified sentence with the words reversed in order.

### Example Walkthrough

For the input sentence `"I love javascript"`:
1. Reverse the entire sentence: `"tpircsavaj evol I"`
2. Reverse each word in the reversed sentence to get the final result:
   - Reverse `"tpircsavaj"` to `"javascript"`
   - Reverse `"evol"` to `"love"`
   - Reverse `"I"` to `"I"`
3. The final output is `"javascript love I"`

### Code Implementation

Here is the code for the `reverseWords` function:

```javascript
function reverseString(sentence, left, right) {
    if (!sentence || sentence.length < 2) return;
    while (left < right) {
        let temp = sentence[left];
        sentence = sentence.substr(0, left) + sentence[right] + sentence.substr(left + 1);
        sentence = sentence.substr(0, right) + temp + sentence.substr(right + 1);
        left++;
        right--;
    }
    return sentence;
}

function reverseWords(sentence) {
    let left = 0;
    let right = 0;
    sentence = sentence.split('').reverse().join('');
    while (true) {
        while (sentence[left] === ' ') left++;
        if (left >= sentence.length) break;
        right = left + 1;
        while (right < sentence.length && sentence[right] != ' ') right++;
        sentence = reverseString(sentence, left, right - 1);
        left = right;
    }
    return sentence;
}

export { reverseWords };
```

### Explanation of the Code

- **reverseString Function**: This helper function reverses a substring of the sentence between the `left` and `right` indices.
  - It uses a while loop to swap characters from the ends towards the center.
  - The function is called to reverse each word in the reversed sentence.
- **reverseWords Function**: This function reverses the order of words in the sentence.
  - **Initial Reversal**: The entire sentence is reversed using `split`, `reverse`, and `join`.
  - **Word Reversal**: Two pointers, `left` and `right`, are used to identify and reverse each word in the reversed sentence.
  - The function iterates through the sentence, reversing each word and skipping spaces.
  - Finally, the function returns the modified sentence with the words in the correct reversed order.

### Conclusion
The solution efficiently reverses the order of words in a sentence while maintaining the original content and spacing. By first reversing the entire sentence and then reversing each word, the function achieves the desired result with O(N) time complexity and O(1) additional space. This approach ensures that the solution is both time and space efficient, meeting the problem's constraints.