Print Words Vertically

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 would be put on only one column and that in one column there will be only one word.

Input & Output

Example 1 — Basic Case

$ Input: s = "HOW ARE YOU"

› Output: ["HAY","ORU","WE"]

💡 Note: Reading vertically: Column 0 = H+A+Y = "HAY", Column 1 = O+R+U = "ORU", Column 2 = W+E = "WE" (no trailing spaces)

Example 2 — Different Lengths

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

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

💡 Note: Words have varying lengths, shorter words contribute spaces. Column 2 has internal spaces but no trailing spaces.

Example 3 — Single Word

$ Input: s = "CONTEST"

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

💡 Note: Single word becomes vertical - each character forms its own column

Constraints

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

Visualization

Tap to expand

Asked in

G Google 12 a Amazon 8 M Microsoft 6

The key insight is to think of words as rows in a matrix and read columns vertically. Split the input string into words, then for each column position, collect characters from all words at that position. Handle shorter words by adding spaces, but remove trailing spaces from each column. The optimal approach builds all columns in a single pass. Time: O(n×m), Space: O(n×m) where n is number of words and m is max word length.

Common Approaches

✓ Brute Force - Column by Column

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

Split the string into words, find the maximum word length, then for each column position from 0 to max length, iterate through all words to collect characters at that position.

Single Pass - Build All Columns

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

Split the string into words, initialize empty result columns, then iterate through each word once, adding each character to its corresponding column position.

Brute Force - Column by Column — Algorithm Steps

Split string into words
Find maximum word length
For each column position, iterate through words
Collect character at position or space if word too short
Remove trailing spaces from each column

Visualization

Tap to expand

Step-by-Step Walkthrough

Split Words

Break input into individual words

For Each Column

Iterate through column positions 0 to max length

Collect Characters

Gather character at current position from each word

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* sCopy = malloc(strlen(s) + 1);
    strcpy(sCopy, s);
    
    char* token = strtok(sCopy, " ");
    while (token != NULL && wordCount < 1000) {
        words[wordCount] = malloc(strlen(token) + 1);
        strcpy(words[wordCount], token);
        wordCount++;
        token = strtok(NULL, " ");
    }
    
    if (wordCount == 0) {
        free(sCopy);
        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;
        }
    }
    
    char** result = malloc(maxLen * sizeof(char*));
    
    for (int col = 0; col < maxLen; col++) {
        char* column = malloc(wordCount + 1);
        for (int i = 0; i < wordCount; i++) {
            if (col < strlen(words[i])) {
                column[i] = words[i][col];
            } else {
                column[i] = ' ';
            }
        }
        column[wordCount] = '\0';
        
        // Remove trailing spaces
        int len = strlen(column);
        while (len > 0 && column[len-1] == ' ') {
            column[len-1] = '\0';
            len--;
        }
        
        result[col] = column;
    }
    
    *returnSize = maxLen;
    
    // Free words and copy
    for (int i = 0; i < wordCount; i++) {
        free(words[i]);
    }
    free(sCopy);
    
    return result;
}

int main() {
    char s[10000];
    fgets(s, sizeof(s), stdin);
    s[strcspn(s, "\n")] = 0;
    
    int returnSize;
    char** result = solution(s, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("\"%s\"", result[i]);
        if (i < returnSize - 1) printf(",");
        free(result[i]);
    }
    printf("]\n");
    
    if (result) free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × m)

Outer loop runs m times (max word length), inner loop runs n times (number of words)

✓ Linear Growth

Space Complexity

O(n × m)

Result array stores up to n×m characters total across all columns

⚡ Linearithmic Space

18.5K Views

Medium Frequency

~15 min Avg. Time

847 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 - Column by Column — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler