Transpose File - Practice Coding Problems

Transpose File - Problem

Shell Medium

Given a text file file.txt, transpose its content. You may assume that each row has the same number of columns, and each field is separated by the ' ' (space) character.

For example: If file.txt has the content:

name age
john 33
mike 80

Your script should output:

name john mike
age 33 80

Note: This is a shell scripting problem that requires reading and processing file content line by line.

Input & Output

Example 1 — Basic Transpose

$ Input: name age\njohn 33\nmike 80

› Output: name john mike\nage 33 80

💡 Note: First row becomes first column: 'name john mike'. Second row becomes second column: 'age 33 80'.

Example 2 — Three Columns

$ Input: a b c\n1 2 3\nx y z

› Output: a 1 x\nb 2 y\nc 3 z

💡 Note: Column 1: a,1,x become row 1. Column 2: b,2,y become row 2. Column 3: c,3,z become row 3.

Example 3 — Two Rows Only

$ Input: hello world\nfoo bar

› Output: hello foo\nworld bar

💡 Note: Transpose 2x2 matrix: first column 'hello foo', second column 'world bar'.

Constraints

Each row has the same number of columns
Fields are separated by single space character
No empty lines in input
Maximum 1000 rows and 100 columns

Visualization

Tap to expand

Understanding the Visualization

Input

Text file with rows and columns separated by spaces

Process

Convert rows to columns and columns to rows

Output

Transposed content where original columns become rows

Key Takeaway

🎯 Key Insight: Transpose converts columns to rows by collecting all values from each column position across all rows

Asked in

G Google 25 a Amazon 18 M Microsoft 15

The key insight is to treat the file as a matrix where rows become columns. Best approach uses column arrays to collect values, then output each column as a row. Time: O(n×m), Space: O(n×m)

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force - Store All Data	O(n×m)	O(n×m)	Read entire file into memory as 2D array, then output by columns
Shell AWK Solution	O(n×m)	O(n×m)	Use AWK to transpose efficiently in one pass

Brute Force - Store All Data — Algorithm Steps

Read all lines into array
Split each line by spaces
For each column index, collect values from all rows
Output each column as a row

Visualization

Tap to expand

Step-by-Step Walkthrough

Read Rows

Store all rows in memory as 2D array

Process Columns

For each column, collect values from all rows

Output

Print each column as a new row

Code -

solution.c — C

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

#define MAX_LINES 1000
#define MAX_COLS 100
#define MAX_WORD_LEN 100

char* solution(const char* content) {
    char lines[MAX_LINES][MAX_WORD_LEN * MAX_COLS];
    char words[MAX_LINES][MAX_COLS][MAX_WORD_LEN];
    int numRows = 0, numCols = 0;
    
    // Parse input into lines
    char* contentCopy = strdup(content);
    char* line = strtok(contentCopy, "\n");
    
    while (line != NULL && numRows < MAX_LINES) {
        strcpy(lines[numRows], line);
        numRows++;
        line = strtok(NULL, "\n");
    }
    
    // Parse each line into words
    for (int i = 0; i < numRows; i++) {
        char* word = strtok(lines[i], " ");
        int colCount = 0;
        while (word != NULL && colCount < MAX_COLS) {
            strcpy(words[i][colCount], word);
            colCount++;
            word = strtok(NULL, " ");
        }
        if (i == 0) numCols = colCount;
    }
    
    // Build result
    char* result = malloc(10000);
    result[0] = '\0';
    
    for (int col = 0; col < numCols; col++) {
        if (col > 0) strcat(result, "\n");
        
        for (int row = 0; row < numRows; row++) {
            if (row > 0) strcat(result, " ");
            strcat(result, words[row][col]);
        }
    }
    
    free(contentCopy);
    return result;
}

int main() {
    char content[10000] = "";
    char line[1000];
    
    while (fgets(line, sizeof(line), stdin)) {
        strcat(content, line);
    }
    
    char* result = solution(content);
    printf("%s", result);
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n×m)

Read n rows with m columns, then output n×m elements

✓ Linear Growth

Space Complexity

O(n×m)

Store entire file content in memory as 2D array

⚡ Linearithmic Space

12.5K Views

Medium Frequency

~15 min Avg. Time

350 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 - Store All Data — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler