2881. Create a New Column

Problem Description

A company has a DataFrame employees that holds two columns: name and salary. The name column is of object type and contains the names of the employees, while the salary column is of integer type and contains each employee's salary. The task is to write a piece of code that adds a new column to the employees DataFrame. This new column, named bonus, is supposed to contain the doubled values of the salary column for each employee. It is essentially a bonus calculation where each employee's bonus is twice their current salary.


The intuition behind the solution is to take advantage of the functionality provided by the pandas library in Python to manipulate DataFrame objects. Pandas allows us to perform vectorized operations on columns, which means operations can be applied to each element of a column without the need for explicit iteration over rows.

Given that the objective is to double the salary for each employee, we can simply select the salary column of the DataFrame and multiply its values by 2. The resulting Series (a one-dimensional array in pandas) can then be assigned to a new column called bonus within the same DataFrame.

This is a straightforward operation, and it involves the following steps:

  1. Multiply the salary column by 2 using the * (multiplication) operator. This operation is inherently element-wise when using pandas Series.
  2. Assign the result of this multiplication to a new column in the DataFrame named bonus. This is done by setting employees['bonus']—which creates the new column—to the result of the multiplication.

The solution is efficient because it does not involve any explicit loops and makes full use of the features of pandas for vectorized operations on DataFrames.

Not Sure What to Study? Take the 2-min Quiz to Find Your Missing Piece:

Which of the following is the prefix sum of array [1, 2, 3, 4, 5]?

Solution Approach

The solution approach for this problem is quite straightforward, thanks to Python's pandas library. Given the goal is to generate a new column named bonus derived from the existing salary column, we follow these steps:

  1. Select the salary column from the employees DataFrame. This can be done with employees['salary'].
  2. Multiply the selected column by 2 to calculate the bonus. In pandas, this operation will automatically apply to each element (i.e., each salary) in the column, resulting in a new Series where each value is double the original.
  3. Assign this new Series to a new column in the employees DataFrame named bonus. This column is created on the fly with the assignment operation: employees['bonus'] = new_series.

Here's an explanation of the elements and concepts used in the implementation:

  • DataFrame: A pandas DataFrame is a two-dimensional, size-mutable, and potentially heterogeneous tabular data structure with labeled axes (rows and columns). In this case, employees is a DataFrame representing a table of employees with columns for name and salary.

  • Series: A Series is a one-dimensional array capable of holding any data type. When we select a single column from a DataFrame (like employees['salary']), we're working with a Series.

  • Element-wise Multiplication: When multiplying the salary Series by 2 (employees['salary'] * 2), pandas applies the multiplication to each element of the Series, doubling every individual salary. This is an efficient vectorized operation that avoids the need for explicit looping.

  • Column Assignment: By setting employees['bonus'] equal to the doubled salaries Series, we're assigning the results of our calculation to a new column in the DataFrame called bonus.

In summary, the implementation uses basic pandas operations to create and calculate a new column in an existing DataFrame, demonstrating simple and effective manipulation of tabular data.

Discover Your Strengths and Weaknesses: Take Our 2-Minute Quiz to Tailor Your Study Plan:

Which of the following problems can be solved with backtracking (select multiple)

Example Walkthrough

Let's say we have the following employees DataFrame:


We want to add a bonus column where each employee's bonus equals twice their salary. Here's how we apply our solution approach:

  1. We select the salary column from the employees DataFrame using employees['salary'].

  2. We calculate the bonus by multiplying every salary by 2. For our example, this would be:

    • Alice's bonus: 70000 * 2 = 140000
    • Bob's bonus: 60000 * 2 = 120000
    • Charlie's bonus: 50000 * 2 = 100000

    This step is performed using employees['salary'] * 2, resulting in a Series that looks like:

    Series IndexValue (bonus)
  3. We assign this Series to the new bonus column in the employees DataFrame. This assignment operation is employees['bonus'] = employees['salary'] * 2.

After executing these steps, our employees DataFrame will be updated to include the new bonus column, resulting in:


The bonus column reflects the doubled salary for each employee, effectively showing the desired calculation. Each step of this process leverages the power of pandas to efficiently handle and compute data in a vectorized manner without the need for explicit looping constructs.

Solution Implementation

1import pandas as pd
3def create_bonus_column(employees_df: pd.DataFrame) -> pd.DataFrame:
4    # Create a new column 'bonus' in the dataframe
5    # The 'bonus' is calculated as double the employee's salary
6    employees_df['bonus'] = employees_df['salary'] * 2
8    # Return the modified dataframe with the new 'bonus' column
9    return employees_df
1import java.util.List;
2import java.util.stream.Collectors;
4// Assuming Employee is a predefined class with at least two fields: name and salary.
5class Employee {
6    private String name;
7    private double salary;
8    private double bonus;
10    // Getter and setter methods for name, salary, and bonus
11    public String getName() {
12        return name;
13    }
15    public void setName(String name) {
16        this.name = name;
17    }
19    public double getSalary() {
20        return salary;
21    }
23    public void setSalary(double salary) {
24        this.salary = salary;
25    }
27    public double getBonus() {
28        return bonus;
29    }
31    public void setBonus(double bonus) {
32        this.bonus = bonus;
33    }
35    // Constructor
36    public Employee(String name, double salary) {
37        this.name = name;
38        this.salary = salary;
39        this.bonus = 0; // bonus initialized to 0
40    }
43public class EmployeeBonusCalculator {
45    /**
46     * Creates a bonus field for each employee and sets it to double their salary.
47     *
48     * @param employees List of Employee objects
49     * @return The list with updated Employee objects including the bonus
50     */
51    public List<Employee> createBonusColumn(List<Employee> employees) {
52        // Loop through each employee in the list and calculate their bonus
53        List<Employee> updatedEmployees = employees.stream().map(employee -> {
54            // Calculate the bonus as double the employee's salary
55            double bonus = employee.getSalary() * 2;
57            // Set the bonus to the employee's record
58            employee.setBonus(bonus);
59            return employee;
60        }).collect(Collectors.toList());
62        // Return the list with updated employees
63        return updatedEmployees;
64    }
1#include <iostream>
2#include <vector>
3#include <map>
4#include <string>
6typedef std::map<std::string, std::string> EmployeeRow;
7typedef std::vector<EmployeeRow> DataFrame;
9DataFrame CreateBonusColumn(DataFrame employees_df) {
10    // Iterate through each employee entry in the dataframe
11    for (auto& employee : employees_df) {
12        // Assume 'salary' is stored as a string, convert it to a double to perform the calculation
13        double salary = std::stod(employee["salary"]);
15        // Double the salary to determine the bonus
16        double bonus = salary * 2;
18        // Store the bonus back in the row, converting it to a string
19        employee["bonus"] = std::to_string(bonus);
20    }
22    // Return the modified dataframe with the new 'bonus' column
23    return employees_df;
26int main() {
27    // Example usage:
28    // Create a sample dataframe with employee salaries
29    DataFrame employees_df = {
30        {{"name", "Alice"}, {"salary", "50000"}},
31        {{"name", "Bob"}, {"salary", "60000"}},
32        {{"name", "Charlie"}, {"salary", "55000"}}
33    };
35    // Add bonus column to the dataframe
36    employees_df = CreateBonusColumn(employees_df);
38    // Print the result to check the 'bonus' column
39    for (const auto& employee : employees_df) {
40        std::cout << "Name: " << employee.at("name") 
41                  << ", Salary: " << employee.at("salary") 
42                  << ", Bonus: " << employee.at("bonus") << std::endl;
43    }
45    return 0;
1// Define an interface to represent the structure of an employee object
2interface Employee {
3    salary: number;
4    // Additional properties can be defined here if they exist
5    // For example, name, id, department, etc.
6    // ...
7    bonus?: number;  // The bonus property is optional because it will be added later
10// Function to create a bonus property for each employee
11function createBonusColumn(employees: Employee[]): Employee[] {
12    // Iterate over the array of employee objects 
13    employees.forEach(employee => {
14        // Calculate the bonus as double the employee's salary and assign it to the 'bonus' property
15        employee.bonus = employee.salary * 2;
16    });
18    // Return the modified array of employee objects with the new 'bonus' property added
19    return employees;
22// Example usage:
23// const employees: Employee[] = [{ salary: 30000 }, { salary: 40000 }];
24// const updatedEmployees = createBonusColumn(employees);
25// console.log(updatedEmployees);
Not Sure What to Study? Take the 2-min Quiz:

What's the output of running the following function using the following tree as input?

1def serialize(root):
2    res = []
3    def dfs(root):
4        if not root:
5            res.append('x')
6            return
7        res.append(root.val)
8        dfs(root.left)
9        dfs(root.right)
10    dfs(root)
11    return ' '.join(res)
1import java.util.StringJoiner;
3public static String serialize(Node root) {
4    StringJoiner res = new StringJoiner(" ");
5    serializeDFS(root, res);
6    return res.toString();
9private static void serializeDFS(Node root, StringJoiner result) {
10    if (root == null) {
11        result.add("x");
12        return;
13    }
14    result.add(Integer.toString(root.val));
15    serializeDFS(root.left, result);
16    serializeDFS(root.right, result);
1function serialize(root) {
2    let res = [];
3    serialize_dfs(root, res);
4    return res.join(" ");
7function serialize_dfs(root, res) {
8    if (!root) {
9        res.push("x");
10        return;
11    }
12    res.push(root.val);
13    serialize_dfs(root.left, res);
14    serialize_dfs(root.right, res);

Time and Space Complexity

The time complexity of the function is O(n), where n is the number of rows in the employees DataFrame. This is because the operation employees['salary'] * 2 is applied to each row to calculate the bonus.

The space complexity of the function is O(n), assuming that the creation of an additional column represents new memory allocation proportional to the number of rows in the DataFrame. If the bonus values are stored as a separate array before being assigned to the DataFrame, this would still entail O(n) additional space.

Fast Track Your Learning with Our Quick Skills Quiz:

What is the best way of checking if an element exists in an unsorted array once in terms of time complexity? Select the best that applies.

Recommended Readings

Got a question? Ask the Teaching Assistant anything you don't understand.

Still not clear? Ask in the Forum,  Discord or Submit the part you don't understand to our editors.

TA 👨‍🏫