Skip to main content
Talentd

Rename Columns - Solution & Explanation

Easy6 min read
Practice this problem

Problem Statement

DataFrame students
+-------------+--------+
| Column Name | Type   |
+-------------+--------+
| id          | int    |
| first       | object |
| last        | object |
| age         | int    |
+-------------+--------+

Write a solution to rename the columns as follows:

  • id to student_id
  • first to first_name
  • last to last_name
  • age to age_in_years

The result format is in the following example.

 

Example 1:
Input:
+----+---------+----------+-----+
| id | first   | last     | age |
+----+---------+----------+-----+
| 1  | Mason   | King     | 6   |
| 2  | Ava     | Wright   | 7   |
| 3  | Taylor  | Hall     | 16  |
| 4  | Georgia | Thompson | 18  |
| 5  | Thomas  | Moore    | 10  |
+----+---------+----------+-----+
Output:
+------------+------------+-----------+--------------+
| student_id | first_name | last_name | age_in_years |
+------------+------------+-----------+--------------+
| 1          | Mason      | King      | 6            |
| 2          | Ava        | Wright    | 7            |
| 3          | Taylor     | Hall      | 16           |
| 4          | Georgia    | Thompson  | 18           |
| 5          | Thomas     | Moore     | 10           |
+------------+------------+-----------+--------------+
Explanation: 
The column names are changed accordingly.

Approach Overview

Problem Overview: You receive a table-like data structure (typically a DataFrame) and a list of new column names. The task is to rename the existing columns so they match the provided list while preserving the underlying data.

Approach 1: Direct Column Assignment (O(n) time, O(1) extra space)

The most straightforward approach updates the column metadata directly. Iterate through the column list or assign the new column list to the table's column property. In environments like Python DataFrames or similar structures, setting df.columns = new_names immediately replaces the existing column labels. The operation touches each column once, so the time complexity is O(n) where n is the number of columns, while space remains O(1) because only metadata changes. This method is ideal when the number of new names exactly matches the current column count and no conditional logic is required.

Approach 2: Library Rename Utility (O(n) time, O(n) space)

Many data-processing libraries provide a built-in rename utility that accepts a mapping between old and new column names. You construct a dictionary or map where keys represent existing column labels and values represent their replacements, then call the library helper (for example rename()). Internally the library iterates over the column list and applies the mapping. The traversal takes O(n) time and the mapping structure requires O(n) extra space. This approach is preferred when only some columns change or when you want safer transformations with explicit mappings.

Both approaches rely on basic dataframe metadata manipulation rather than complex algorithms. The key operation is iterating across column identifiers and updating their labels. In some implementations, column names are stored in an array-like structure or managed through a hash map for quick lookup during rename operations.

Recommended for interviews: Direct column reassignment is typically the cleanest and most efficient solution when the problem guarantees the new name list matches the column count. It demonstrates you understand how column metadata works internally. The mapping-based rename utility is useful when partial renaming is required and shows familiarity with built-in library features. Interviewers usually expect the O(n) traversal approach because every column must be processed at least once.

Approach 1: Data Structure Manipulation

This approach focuses on manipulating the data structures that hold the DataFrame or its equivalent to rename the columns. The idea is to access the data structure directly and modify the column headers.

In Python, the Pandas library provides a rename function which can easily rename columns. The rename method takes a dictionary where keys are existing column names and values are the new names.

Code

PythonJavaScript

Python

JavaScript

Complexity

Time Complexity: O(1) as renaming columns in a DataFrame does not depend on the number of rows.
Space Complexity: O(1), no additional space required beyond the rename operation.

Try this approach in the editor →

Approach 2: Library Specific Utility

This approach relies on using specific libraries available for each programming language that are geared towards data manipulation. These libraries often offer built-in functionalities for renaming columns effortlessly.

In C#, the DataTable structure from System.Data namespace is used to represent the data. To rename columns, we update the ColumnName property of the appropriate columns in the DataTable.Columns collection.

Code

C#Java

C#

Java

Complexity

Time Complexity: O(1) since column renaming is independent of the data in the table.
Space Complexity: O(1) because it modifies column names in-place.

Try this approach in the editor →

Approach 3: Default Approach

Code

Python

Python

Try this approach in the editor →

Complexity Comparison

ApproachComplexity
Data Structure Manipulation

Time Complexity: O(1) as renaming columns in a DataFrame does not depend on the number of rows.
Space Complexity: O(1), no additional space required beyond the rename operation.

Library Specific Utility

Time Complexity: O(1) since column renaming is independent of the data in the table.
Space Complexity: O(1) because it modifies column names in-place.

Default Approach—

Detailed Complexity Analysis

ApproachTimeSpaceWhen to Use
Direct Column AssignmentO(n)O(1)When replacing all column names with a new ordered list
Library Rename Utility (Mapping)O(n)O(n)When renaming only specific columns or using explicit old-to-new mappings

Video Solution

2885. Rename Columns | LeetCode | Python | Pandas • You Data And AI • 610 views views

Watch 8 more video solutions →

Frequently Asked Questions

Is Rename Columns easy or hard?
Rename Columns is considered an Easy problem. The task focuses on understanding how table schemas store column labels and applying a simple iteration or built-in rename operation without complex algorithms.
Rename Columns Python/Java solution
Python solutions typically modify the DataFrame directly using column reassignment or the rename() utility. In Java or C#, similar behavior is implemented through table metadata APIs or mapping-based rename functions. All approaches iterate through the column list once, resulting in O(n) time complexity.
How to solve Rename Columns in O(n)?
Traverse the column list and update the labels with the new names. In DataFrame-style structures, you can directly assign the new column list to the column metadata property. Because each column is processed exactly once, the operation runs in O(n) time.
What is the best approach for Rename Columns?
The most efficient approach is direct column reassignment. Replace the column list with the new names in one operation, which processes each column once for O(n) time and O(1) extra space. This works best when the number of new names exactly matches the existing column count.
Is Rename Columns asked at Google/Amazon/Meta?
Rename Columns represents a basic data manipulation pattern often used in data engineering and analytics interviews. While the exact problem may not appear frequently in big-tech algorithm rounds, similar tasks involving DataFrame transformations and metadata updates are common in data-focused roles.
What data structure is used in Rename Columns?
Most implementations store column names in an array-like structure attached to the DataFrame schema. Some rename utilities also use a hash map or dictionary to map old column names to new ones before applying the transformation.
What is the time complexity of Rename Columns?
Renaming columns requires processing each column label at least once. The time complexity is O(n), where n is the number of columns in the table. Direct reassignment uses O(1) extra space, while mapping-based rename utilities typically require O(n) space for the mapping structure.

Ready to solve this problem?

Practice Rename Columns with our built-in code editor and test cases.

Practice on FleetCode