Transpose File

Med

#0184Time: O(R * C)Space: O(R * C)

Prompt

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 ' ' character.

Example:

If file.txt has the following content:

name age
alice 21
ryan 30

Output the following:

name alice ryan
age 21 30

Approaches

3 approaches with complexity analysis and trade-offs.

This approach involves reading the entire file into a 2D array or list of lists. A second 2D array of transposed dimensions is then created. The data is copied from the original matrix to the transposed matrix by swapping the row and column indices. Finally, the transposed matrix is printed to the standard output.

Algorithm

Read all lines from the file.
Split each line into words and store them in a 2D list, originalData.
Determine dimensions: rows = originalData.size() and cols = originalData.get(0).size().
Create a new 2D array, transposedData, of size cols x rows.
Populate transposedData using the formula transposedData[i][j] = originalData.get(j).get(i).
Print each row of transposedData.

Walkthrough

This approach is the most direct translation of the matrix transpose operation. It first loads the entire file content into an in-memory 2D data structure, like a List<String[]>. This represents the original matrix.

Once the data is loaded, it determines the dimensions (rows R and columns C). It then allocates a second 2D array with swapped dimensions (C x R). A nested loop iterates through the new dimensions, and for each cell (i, j) in the transposed matrix, it fetches the corresponding element from the original matrix at (j, i).

After the transposed matrix is fully populated, another loop iterates through it to print each row to the console, with elements separated by spaces.

1import java.io.BufferedReader;2import java.io.FileReader;3import java.io.IOException;4import java.util.ArrayList;5import java.util.List;6 7public class Solution {8    public void transposeFile(String filePath) throws IOException {9        List<String[]> lines = new ArrayList<>();10        try (BufferedReader reader = new BufferedReader(new FileReader(filePath))) {11            String line;12            while ((line = reader.readLine()) != null) {13                lines.add(line.split(" "));14            }15        }16 17        if (lines.isEmpty()) {18            return;19        }20 21        int rows = lines.size();22        int cols = lines.get(0).length;23 24        String[][] transposed = new String[cols][rows];25 26        for (int i = 0; i < cols; i++) {27            for (int j = 0; j < rows; j++) {28                transposed[i][j] = lines.get(j)[i];29            }30        }31 32        for (int i = 0; i < cols; i++) {33            System.out.println(String.join(" ", transposed[i]));34        }35    }36}

Complexity

Time

O(R * C)

Space

O(R * C)

Trade-offs

Pros

Very straightforward and easy to reason about.
Separates the logic of data loading, transformation, and presentation.

Cons

Highest memory usage as it stores two copies of the data (in different layouts).
Not suitable for very large files that cannot fit into memory twice.

This approach improves on the brute-force method by reducing memory usage. It still reads the entire file into a 2D data structure. However, instead of creating a second, separate transposed matrix, it directly constructs and prints each transposed row. It iterates through the column indices of the original data, and for each column, it builds the corresponding output row by collecting elements from each input row.

Algorithm

Read all lines from the file.
Split each line into words and store them in a 2D list, originalData.
Determine dimensions: rows = originalData.size() and cols = originalData.get(0).size().
Iterate from i = 0 to cols - 1 (for each output row).
Inside the loop, create a StringBuilder.
Start an inner loop from j = 0 to rows - 1 (for each input row).
Append the element originalData.get(j).get(i) to the StringBuilder.
After the inner loop, print the StringBuilder's content.

Walkthrough

This method improves upon the brute-force approach by eliminating the need for a second 2D array to store the transposed data. It still begins by loading the entire file into a 2D list in memory.

However, instead of building a complete transposed matrix, it generates the output line by line. The algorithm iterates through the column indices of the original data. For each column index i, it constructs the i-th row of the output. It does this by iterating through all the rows of the in-memory data and picking out the element at column i from each one. These elements are collected into a StringBuilder, which is then printed before moving to the next column. This reduces peak memory usage by not holding both the original and transposed matrices simultaneously.

1import java.io.BufferedReader;2import java.io.FileReader;3import java.io.IOException;4import java.util.ArrayList;5import java.util.List;6 7public class Solution {8    public void transposeFile(String filePath) throws IOException {9        List<String[]> lines = new ArrayList<>();10        try (BufferedReader reader = new BufferedReader(new FileReader(filePath))) {11            String line;12            while ((line = reader.readLine()) != null) {13                lines.add(line.split(" "));14            }15        }16 17        if (lines.isEmpty()) {18            return;19        }20 21        int rows = lines.size();22        int cols = lines.get(0).length;23 24        for (int i = 0; i < cols; i++) {25            StringBuilder outputLine = new StringBuilder();26            for (int j = 0; j < rows; j++) {27                outputLine.append(lines.get(j)[i]);28                if (j < rows - 1) {29                    outputLine.append(" ");30                }31            }32            System.out.println(outputLine.toString());33        }34    }35}

Complexity

Time

O(R * C)

Space

O(R * C)

Trade-offs

Pros

More memory-efficient than the brute-force approach as it avoids creating a second large 2D array.
Still relatively simple to implement.

Cons

Still requires storing the entire file content in memory, making it unsuitable for very large files.

This is the most memory-efficient of the in-memory approaches. It mimics the logic of common awk solutions. It reads the file line by line only once. It maintains an array of StringBuilders, where each builder corresponds to a column in the input (and a row in the output). As each line is read, its words are appended to the corresponding StringBuilder. This avoids storing the entire file content in a 2D array of strings, instead directly building the final output lines.

Algorithm

Initialize an empty list of StringBuilders, outputBuilders.
Read the input file line by line.
For the first line read, split it into words. For each word, create a new StringBuilder in outputBuilders and initialize it with the word.
For each subsequent line, split it into words. For each word at index i, append it (with a preceding space) to the StringBuilder at outputBuilders.get(i).
After processing all lines, iterate through outputBuilders and print each StringBuilder.

Walkthrough

This approach is the most efficient in terms of memory management and processing flow. It processes the input file in a single pass and builds the transposed output lines incrementally. It avoids creating a complete 2D representation of the input file.

It maintains a list of StringBuilders, where the size of the list is equal to the number of columns in the file. As it reads each line from the file, it splits the line into words and appends each word to the corresponding StringBuilder in the list. The first line's words initialize the builders, and subsequent lines' words are appended with a space separator. This way, the final output lines are constructed directly without any intermediate 2D data structures, leading to lower object overhead compared to other in-memory methods.

1import java.io.BufferedReader;2import java.io.FileReader;3import java.io.IOException;4import java.util.ArrayList;5import java.util.List;6 7public class Solution {8    public void transposeFile(String filePath) throws IOException {9        List<StringBuilder> outputLines = new ArrayList<>();10        boolean isFirstLine = true;11 12        try (BufferedReader reader = new BufferedReader(new FileReader(filePath))) {13            String line;14            while ((line = reader.readLine()) != null) {15                String[] words = line.split(" ");16                if (isFirstLine) {17                    for (String word : words) {18                        outputLines.add(new StringBuilder(word));19                    }20                    isFirstLine = false;21                } else {22                    for (int i = 0; i < words.length; i++) {23                        outputLines.get(i).append(" ").append(words[i]);24                    }25                }26            }27        }28 29        for (StringBuilder sb : outputLines) {30            System.out.println(sb.toString());31        }32    }33}

Complexity

Time

O(R * C)

Space

O(R * C)

Trade-offs

Pros

Processes the input file in a single pass.
Most memory-efficient in-memory solution due to avoiding intermediate data structures like a 2D array of String objects, resulting in lower constant factors for memory usage.

Cons

Like all in-memory solutions, it will fail if the file is too large to store its content (or transposed content) in memory.

Video walkthrough

Newsletter

One sharp idea, every week

System design and interview prep — short enough to finish.

No spam. Unsubscribe anytime.

Practice

Same difficulty — related problems to reinforce the pattern.

← Previous

Previous problem

Next problem