Print Words Vertically - Practice Coding Problems

Print Words Vertically - Problem

Given a string s, return all the words vertically in the same order in which they appear in s.

Words are returned as a list of strings, complete with spaces when necessary. Trailing spaces are not allowed.

Each word is put on only one column and in one column there will be only one word.

Input & Output

Example 1 — Basic Case

$ Input: s = "HOW ARE YOU"

› Output: ["HAY","ORO","WEU"]

💡 Note: Split into words: ["HOW", "ARE", "YOU"]. Read vertically: H-A-Y forms first row, O-R-O forms second row, W-E-U forms third row.

Example 2 — Different Lengths

$ Input: s = "TO BE OR NOT TO BE"

› Output: ["TBONTB","OEROOE"," T"]

💡 Note: Words have different lengths, so shorter words contribute spaces. Third row has trailing space removed.

Example 3 — Single Word

$ Input: s = "CONTEST"

› Output: ["C","O","N","T","E","S","T"]

💡 Note: Single word becomes vertical list of its characters, one character per row.

Constraints

1 ≤ s.length ≤ 200
s contains only upper case English letters
It's guaranteed that there is only one space between two consecutive words

Visualization

Tap to expand

Understanding the Visualization

Input

String with space-separated words: "HOW ARE YOU"

Arrange Vertically

Place words as columns, read rows horizontally

Output

Array of strings representing each row: ["HAY", "ORO", "WEU"]

Key Takeaway

🎯 Key Insight: Transform the problem into reading matrix rows after arranging words as columns

Asked in

G Google 15 M Microsoft 12 a Amazon 8

The key insight is to treat this as a matrix transpose problem where words are columns and we need to read rows. Split the input into words, then for each character position, collect characters from all words at that position to form the vertical output. The optimal approach builds all rows simultaneously in a single pass. Time: O(n × m), Space: O(n × m) where n is number of words and m is average word length.

Common Approaches

Approach	Time	Space	Notes
✓ Single Pass Optimized	O(n × m)	O(n × m)	Build all rows simultaneously in a single pass through the words
Brute Force - Character by Character	O(n × m)	O(n × m)	Split words, then for each row position, iterate through all words to build the row

Single Pass Optimized — Algorithm Steps

Split input into words and find maximum length
Initialize result array with empty strings
For each word, append its characters to corresponding positions in result
Trim trailing spaces from each result string

Code -

solution.c — C

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

char** solution(char* s, int* returnSize) {
    *returnSize = 0;
    if (!s || strlen(s) == 0) return NULL;
    
    // Split string into words
    char* words[1000];
    int wordCount = 0;
    char* token = strtok(s, " ");
    while (token != NULL && wordCount < 1000) {
        words[wordCount] = malloc(strlen(token) + 1);
        strcpy(words[wordCount], token);
        wordCount++;
        token = strtok(NULL, " ");
    }
    
    if (wordCount == 0) return NULL;
    
    // Find max length
    int maxLen = 0;
    for (int i = 0; i < wordCount; i++) {
        int len = strlen(words[i]);
        if (len > maxLen) maxLen = len;
    }
    
    // Create result array
    char** result = malloc(maxLen * sizeof(char*));
    *returnSize = maxLen;
    
    for (int i = 0; i < maxLen; i++) {
        result[i] = malloc(wordCount + 1);
        result[i][0] = '\0';
    }
    
    for (int w = 0; w < wordCount; w++) {
        for (int i = 0; i < maxLen; i++) {
            char ch = (i < strlen(words[w])) ? words[w][i] : ' ';
            int len = strlen(result[i]);
            result[i][len] = ch;
            result[i][len + 1] = '\0';
        }
    }
    
    // Remove trailing spaces
    for (int i = 0; i < maxLen; i++) {
        int pos = strlen(result[i]);
        while (pos > 0 && result[i][pos-1] == ' ') {
            result[i][--pos] = '\0';
        }
    }
    
    // Free words
    for (int i = 0; i < wordCount; i++) {
        free(words[i]);
    }
    
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × m)

One pass through n words, each with average length m

✓ Linear Growth

Space Complexity

O(n × m)

Result array storing n words × m characters total

⚡ Linearithmic Space

28.5K Views

Medium Frequency

~15 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