Truncate Sentence - Practice Coding Problems

Truncate Sentence - Problem

Array String Easy

Truncate Sentence is a fundamental string manipulation problem that challenges you to extract the first k words from a given sentence.

You are given a sentence s which is a list of words separated by single spaces with no leading or trailing spaces. Each word consists only of uppercase and lowercase English letters (no punctuation). You are also given an integer k.

Your task is to truncate the sentence so that it contains only the first k words and return the truncated sentence.

For example:
• "Hello World Example" with k=2 becomes "Hello World"
• "HELLO" with k=1 remains "HELLO"
• "hello world hello world" with k=3 becomes "hello world hello"

Input & Output

example_1.py — Basic Truncation

$ Input: s = "Hello World Example", k = 2

› Output: "Hello World"

💡 Note: The first 2 words are "Hello" and "World", so we return "Hello World".

example_2.py — Single Word

$ Input: s = "HELLO", k = 1

› Output: "HELLO"

💡 Note: The sentence has only one word, and we want the first 1 word, so we return the entire sentence.

example_3.py — k equals word count

$ Input: s = "hello world hello world", k = 4

› Output: "hello world hello world"

💡 Note: The sentence has exactly 4 words, and k=4, so we return the entire sentence unchanged.

Constraints

1 ≤ s.length ≤ 500
k is a positive integer
1 ≤ k ≤ number of words in s
s consists of only uppercase and lowercase English letters and spaces
The words in s are separated by single spaces
s does not have leading or trailing spaces

Visualization

Tap to expand

Understanding the Visualization

Start Scanning

Begin reading the sentence character by character

Count Word Boundaries

Each space represents the end of a word

Stop at Target

When we find the kth space, we've found k words

Extract Result

Return everything from start to that position

Key Takeaway

🎯 Key Insight: By finding the position of the kth space, we can extract exactly k words in a single pass without needing to split the entire string.

Asked in

⊞ Microsoft 25 a Amazon 18 G Google 12 f Meta 8

The optimal solution uses a single-pass approach to find the position of the kth space and returns a substring up to that point. This achieves O(n) time complexity with O(1) extra space, making it more efficient than splitting and rejoining approaches.

Common Approaches

Approach	Time	Space	Notes
✓ Split and Join Approach	O(n)	O(n)	Split the sentence into words array, then take first k words and join them back
Find kth Space (Optimal)	O(n)	O(1)	Find the position of the kth space and substring up to that point
Brute Force (Character by Character)	O(n)	O(n)	Iterate through each character, count words manually, and build result character by character

Split and Join Approach — Algorithm Steps

Split the sentence by spaces to get array of words
Take the first k words using array slicing
Join the selected words back with spaces
Return the resulting truncated sentence

Visualization

Tap to expand

Step-by-Step Walkthrough

Split

Break sentence into individual words

Slice

Take only the first k words

Join

Combine selected words back with spaces

Code -

solution.c — C

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

char* truncateSentence(char* s, int k) {
    char* words[1000];
    int wordCount = 0;
    char* token = strtok(s, " ");
    
    while (token != NULL && wordCount < k) {
        words[wordCount] = token;
        wordCount++;
        token = strtok(NULL, " ");
    }
    
    int totalLen = 0;
    for (int i = 0; i < k; i++) {
        totalLen += strlen(words[i]);
        if (i > 0) totalLen++; // space
    }
    
    char* result = (char*)malloc((totalLen + 1) * sizeof(char));
    strcpy(result, words[0]);
    
    for (int i = 1; i < k; i++) {
        strcat(result, " ");
        strcat(result, words[i]);
    }
    
    return result;
}

int main() {
    char s[500];
    int k;
    fgets(s, sizeof(s), stdin);
    s[strcspn(s, "\n")] = 0;
    memmove(s, s+1, strlen(s));
    s[strlen(s)-1] = '\0';
    scanf("%d", &k);
    char* result = truncateSentence(s, k);
    printf("\"%s\"", result);
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Split operation scans the entire string once, join operation processes k words

✓ Linear Growth

Space Complexity

O(n)

Creates an array to store all words from the sentence

⚡ Linearithmic Space

28.0K Views

Medium Frequency

~15 min Avg. Time

890 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

Split and Join Approach — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler