Sorting the Sentence

Sorting the Sentence - Problem

String Sorting Easy

A sentence is a list of words that are separated by a single space with no leading or trailing spaces. Each word consists of lowercase and uppercase English letters.

A sentence can be shuffled by appending the 1-indexed word position to each word then rearranging the words in the sentence.

For example, the sentence "This is a sentence" can be shuffled as "sentence4 a3 is2 This1" or "is2 sentence4 This1 a3".

Given a shuffled sentence s containing no more than 9 words, reconstruct and return the original sentence.

Input & Output

Example 1 — Basic Case

$ Input: s = "is2 sentence4 This1 Test5 est6"

› Output: "This is sentence sentence Test est"

💡 Note: Sort words by their position digits: This1→position 1, is2→position 2, sentence4→position 4, Test5→position 5, est6→position 6.

Example 2 — Different Order

$ Input: s = "Myself2 Me1 I4 and3"

› Output: "Me Myself and I"

💡 Note: Rearrange by positions: Me1, Myself2, and3, I4 becomes "Me Myself and I"

Example 3 — Single Word

$ Input: s = "T4est1"

› Output: "T4est"

💡 Note: Single word with position 1, just remove the digit to get "T4est"

Constraints

s contains only lowercase and uppercase English letters, spaces and digits from 1 to 9
All the words in s are separated by a single space
s contains between 1 and 9 words, inclusive
Each word in s consists of lowercase and uppercase English letters
All the words have a unique position digit

Visualization

Tap to expand

Asked in

a Amazon 15 M Microsoft 12

The key insight is that each word contains its correct position as the last character. We can extract this digit, remove it from the word, and place the cleaned word at the correct position in a result array. The optimal Array Placement approach runs in O(n) time and O(n) space by directly placing words at their target positions.

Common Approaches

✓ Brute Force Array Placement

⏱️ Time: O(n) Space: O(n)

Split the sentence into words, check the last character of each word to get its position, remove the digit, and place the word at the correct index in a result array.

Sort by Position

⏱️ Time: O(n log n) Space: O(n)

Create pairs of (word, position) for each word, sort by position, then extract the words to form the result sentence.

Brute Force Array Placement — Algorithm Steps

Step 1: Split shuffled sentence into individual words
Step 2: For each word, extract the position digit and remove it
Step 3: Place the cleaned word at position-1 in result array
Step 4: Join the result array back into a sentence

Visualization

Tap to expand

Step-by-Step Walkthrough

Split Words

Break shuffled sentence into individual words

Extract Position

Get position digit from each word and remove it

Place in Array

Put cleaned word at correct index in result array

Code -

solution.c — C

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

char* solution(char* s) {
    char* words[9];
    char* result[9];
    int wordCount = 0;
    int maxPos = 0;
    
    // Split string into words and find maximum position
    char* sCopy = malloc(strlen(s) + 1);
    strcpy(sCopy, s);
    
    char* token = strtok(sCopy, " ");
    while (token != NULL && wordCount < 9) {
        words[wordCount] = malloc(strlen(token) + 1);
        strcpy(words[wordCount], token);
        
        int len = strlen(token);
        int pos = token[len-1] - '0';
        if (pos > maxPos) {
            maxPos = pos;
        }
        
        wordCount++;
        token = strtok(NULL, " ");
    }
    
    // Place words in correct positions
    for (int i = 0; i < wordCount; i++) {
        int len = strlen(words[i]);
        int position = words[i][len-1] - '0' - 1;
        words[i][len-1] = '\0';  // Remove digit
        result[position] = words[i];
    }
    
    // Create final result string
    char* finalResult = malloc(1000);
    strcpy(finalResult, result[0]);
    for (int i = 1; i < maxPos; i++) {
        strcat(finalResult, " ");
        strcat(finalResult, result[i]);
    }
    
    free(sCopy);
    return finalResult;
}

int main() {
    char s[1000];
    fgets(s, sizeof(s), stdin);
    s[strcspn(s, "\n")] = 0;  // Remove newline
    
    char* result = solution(s);
    printf("%s\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through n words to extract positions and place them

✓ Linear Growth

Space Complexity

O(n)

Result array stores n words plus intermediate word list

⚡ Linearithmic Space

33.9K Views

Medium Frequency

~8 min Avg. Time

892 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

Brute Force Array Placement — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler