Print Words Vertically - Practice Coding Problems

Print Words Vertically - Problem

Print Words Vertically is a fascinating string manipulation problem that challenges you to think about text layout and matrix-like operations on strings.

Given a string s containing multiple words separated by spaces, your task is to arrange these words vertically in columns. Each word occupies its own column, and you read the result row by row.

For example, if you have "HOW ARE YOU", the words should be arranged like:

H A Y
O R O
W E U

The output should be ["HAY", "ORO", "WEU"].

Key Rules:
• Each word goes in its own column
• Read the result row by row to form output strings
• Add spaces when necessary to align shorter words
• No trailing spaces allowed in the output strings
• Words appear in the same order as the input

Input & Output

example_1.py — Basic Case

$ Input: s = "HOW ARE YOU"

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

💡 Note: We arrange the three words vertically: H-A-Y in first row, O-R-O in second row, W-E-U in third row. Each word forms a column, and we read horizontally to get the result.

example_2.py — Uneven Lengths

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

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

💡 Note: Words have different lengths. Shorter words are padded with spaces. The result shows how spaces are added to align words, but trailing spaces are removed from each result string.

example_3.py — Single Word

$ Input: s = "CONTEST"

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

💡 Note: With only one word, each character becomes a separate row in the result. This is the edge case where we have only one column.

Constraints

1 ≤ s.length ≤ 200
s contains only upper case English letters and spaces
There is exactly one space between consecutive words
Words contain only uppercase letters A-Z
The result must not have trailing spaces

Visualization

Tap to expand

Understanding the Visualization

Parse Input

Split 'HOW ARE YOU' into individual words

Determine Grid Size

Max word length (3) determines number of output rows

Fill Columns

Each word fills one column from top to bottom

Read Rows

Read horizontally to get final result strings

Clean Up

Remove trailing spaces from each result

Key Takeaway

🎯 Key Insight: Transform the problem from thinking about a 2D grid to directly building result strings. Each character gets placed exactly once in its correct position, making this an optimal O(n×m) solution.

Asked in

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

The optimal solution uses a single-pass algorithm that builds all result strings simultaneously. We split the input into words, initialize a result array with size equal to the longest word, then process each word by distributing its characters to the appropriate positions in our result strings. The key insight is that we can build vertically while processing horizontally, using smart padding to handle words of different lengths.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Character by Character)	O(n × m)	O(n × m)	Check every position in a 2D grid and build result character by character
Optimized Single Pass (Optimal)	O(n × m)	O(n × m)	Build all result rows simultaneously in a single pass through the words

Brute Force (Character by Character) — Algorithm Steps

Split the input string into individual words
Find the maximum word length to determine number of rows needed
For each row from 0 to max_length-1:
For each word, check if it has a character at current row index
If yes, add the character; if no, add a space
Remove trailing spaces from each result string

Visualization

Tap to expand

Step-by-Step Walkthrough

Split Words

Split input 'HOW ARE YOU' into ['HOW', 'ARE', 'YOU']

Find Max Length

Max length is 3, so we need 3 rows

Fill Row 0

Take 1st char of each word: H, A, Y → 'HAY'

Fill Row 1

Take 2nd char of each word: O, R, O → 'ORO'

Fill Row 2

Take 3rd char of each word: W, E, U → 'WEU'

Code -

solution.c — C

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

#define MAX_WORDS 100
#define MAX_WORD_LEN 100
#define MAX_INPUT_LEN 1000

char** printVertically(char* s, int* returnSize) {
    char words[MAX_WORDS][MAX_WORD_LEN];
    int wordCount = 0;
    int maxLen = 0;
    
    char* token = strtok(s, " ");
    while (token != NULL && wordCount < MAX_WORDS) {
        strcpy(words[wordCount], token);
        int len = strlen(token);
        if (len > maxLen) maxLen = len;
        wordCount++;
        token = strtok(NULL, " ");
    }
    
    char** result = (char**)malloc(maxLen * sizeof(char*));
    *returnSize = maxLen;
    
    for (int row = 0; row < maxLen; row++) {
        result[row] = (char*)malloc((wordCount + 1) * sizeof(char));
        int pos = 0;
        
        for (int col = 0; col < wordCount; col++) {
            if (row < strlen(words[col])) {
                result[row][pos++] = words[col][row];
            } else {
                result[row][pos++] = ' ';
            }
        }
        result[row][pos] = '\0';
        
        // Remove trailing spaces
        while (pos > 0 && result[row][pos-1] == ' ') {
            result[row][--pos] = '\0';
        }
    }
    
    return result;
}

int main() {
    char input[MAX_INPUT_LEN];
    fgets(input, sizeof(input), stdin);
    
    // Remove quotes if present
    char* start = input;
    char* end = input + strlen(input) - 1;
    if (*end == '\n') *end-- = '\0';
    if (*start == '"') start++;
    if (*end == '"') *end = '\0';
    
    int returnSize;
    char** result = printVertically(start, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("\"%s\"", result[i]);
        if (i < returnSize - 1) printf(", ");
        free(result[i]);
    }
    printf("]\n");
    free(result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × m)

Where n is the number of words and m is the length of the longest word. We iterate through each position in the virtual 2D matrix.

✓ Linear Growth

Space Complexity

O(n × m)

We store the result strings and potentially create intermediate strings during concatenation.

⚡ Linearithmic Space

24.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

Brute Force (Character by Character) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler