Scenario: Employee Bonus Calculator

Imagine you're working for a company that wants to calculate employee bonuses based on their
performance and years of service. The company has the following rules:

1.​ Employees with a performance score above 80 get a bonus.

2.​ ​
The bonus is calculated as:​

○​ 10% of their salary if they've worked less than 5 years.

○​ ​
15% of their salary if they've worked 5-10 years.
○​ ​
20% of their salary if they've worked more than 10 years.
3.​ ​

4.​ ​
If the performance score is below 80, they get no bonus.

You're given a list of employee data in the form of dictionaries, and your task is to write a Python
function to calculate the bonuses and return a report.

Example Input:

python

WrapCopy

employees = [
{"name": "Alice", "salary": 60000, "performance_score": 85,
"years_of_service": 3},
{"name": "Bob", "salary": 75000, "performance_score": 92,
"years_of_service": 7},
{"name": "Charlie", "salary": 50000, "performance_score": 78,
"years_of_service": 12},
 {"name": "Diana", "salary": 80000, "performance_score": 95,
"years_of_service": 15}
]

Expected Output:

A list of dictionaries showing each employee's name, bonus amount, and a message explaining
the result.

Solution

Here’s a Python script that solves this scenario:

python

WrapCopy

def calculate_bonus(employees):
report = []

for employee in employees:

name = employee["name"]
salary = employee["salary"]
score = employee["performance_score"]
years = employee["years_of_service"]

# Check if eligible for bonus

if score > 80:
# Determine bonus percentage based on years of service
if years < 5:
bonus_percentage = 0.10
elif 5 <= years <= 10:
bonus_percentage = 0.15
else:
bonus_percentage = 0.20
 # Calculate bonus
bonus = salary * bonus_percentage
message = f"{name} gets a bonus of ${bonus:.2f} based on {years}
years of service."
else:
bonus = 0
message = f"{name} is not eligible for a bonus due to a
performance score of {score}."

# Add result to report

report.append({"name": name, "bonus": bonus, "message": message})

return report

# Test data
employees = [
{"name": "Alice", "salary": 60000, "performance_score": 85,
"years_of_service": 3},
{"name": "Bob", "salary": 75000, "performance_score": 92,
"years_of_service": 7},
{"name": "Charlie", "salary": 50000, "performance_score": 78,
"years_of_service": 12},
{"name": "Diana", "salary": 80000, "performance_score": 95,
"years_of_service": 15}
]

# Run the function and display results

results = calculate_bonus(employees)
for result in results:
print(result["message"])

Output

text

WrapCopy

Alice gets a bonus of $6000.00 based on 3 years of service.

Bob gets a bonus of $11250.00 based on 7 years of service.

Charlie is not eligible for a bonus due to a performance score of 78.

Diana gets a bonus of $16000.00 based on 15 years of service.

Why This is Helpful for an Interview

1.​ Problem-Solving: It shows you can break down a real-world problem into logical steps.
2.​ ​
Python Basics: Uses dictionaries, conditionals (if-elif-else), loops, and string formatting.
3.​ ​
Clarity: The code is readable and well-structured, which interviewers value.
4.​ ​
Edge Cases: You can discuss how to handle edge cases (e.g., negative salaries,
missing data) if asked.
5.​ ​
Scalability: You can extend this by adding features like input validation or sorting the
report.

How to Use This in an Interview

●​ Explain Your Approach: Start by walking through the problem (e.g., "First, I’ll check the
performance score, then calculate the bonus based on years of service").
●​ ​
Code Step-by-Step: Write the solution incrementally while explaining your thought
process.
●​ ​
Discuss Improvements: Mention how you could add error handling (e.g., try-except for
invalid inputs) or optimize it for larger datasets.

Scenario: Employee Bonus Calculator

Imagine you're working for a company that wants to calculate employee bonuses based on their
performance and years of service. The company has the following rules:

1.​ Employees with a performance score above 80 get a bonus.

2.​ ​
The bonus is calculated as:​

○​ 10% of their salary if they've worked less than 5 years.

○​ ​
15% of their salary if they've worked 5-10 years.
○​ ​
20% of their salary if they've worked more than 10 years.
3.​ ​

4.​ ​
If the performance score is below 80, they get no bonus.

You're given a list of employee data in the form of dictionaries, and your task is to write a Python
function to calculate the bonuses and return a report.

Example Input:

python

WrapCopy

employees = [
{"name": "Alice", "salary": 60000, "performance_score": 85,
"years_of_service": 3},
{"name": "Bob", "salary": 75000, "performance_score": 92,
"years_of_service": 7},
{"name": "Charlie", "salary": 50000, "performance_score": 78,
"years_of_service": 12},
{"name": "Diana", "salary": 80000, "performance_score": 95,
"years_of_service": 15}
]
Expected Output:

A list of dictionaries showing each employee's name, bonus amount, and a message explaining
the result.

Solution

Here’s a Python script that solves this scenario:

python

WrapCopy

def calculate_bonus(employees):
report = []

for employee in employees:

name = employee["name"]
salary = employee["salary"]
score = employee["performance_score"]
years = employee["years_of_service"]

# Check if eligible for bonus

if score > 80:
# Determine bonus percentage based on years of service
if years < 5:
bonus_percentage = 0.10
elif 5 <= years <= 10:
bonus_percentage = 0.15
else:
bonus_percentage = 0.20

# Calculate bonus
bonus = salary * bonus_percentage
message = f"{name} gets a bonus of ${bonus:.2f} based on {years}
years of service."
 else:
bonus = 0
message = f"{name} is not eligible for a bonus due to a
performance score of {score}."

# Add result to report

report.append({"name": name, "bonus": bonus, "message": message})

return report

# Test data
employees = [
{"name": "Alice", "salary": 60000, "performance_score": 85,
"years_of_service": 3},
{"name": "Bob", "salary": 75000, "performance_score": 92,
"years_of_service": 7},
{"name": "Charlie", "salary": 50000, "performance_score": 78,
"years_of_service": 12},
{"name": "Diana", "salary": 80000, "performance_score": 95,
"years_of_service": 15}
]

# Run the function and display results

results = calculate_bonus(employees)
for result in results:
print(result["message"])

Output

text

WrapCopy

Alice gets a bonus of $6000.00 based on 3 years of service.

Bob gets a bonus of $11250.00 based on 7 years of service.

Charlie is not eligible for a bonus due to a performance score of 78.

Diana gets a bonus of $16000.00 based on 15 years of service.

Why This is Helpful for an Interview

1.​ Problem-Solving: It shows you can break down a real-world problem into logical steps.
2.​ ​
Python Basics: Uses dictionaries, conditionals (if-elif-else), loops, and string formatting.
3.​ ​
Clarity: The code is readable and well-structured, which interviewers value.
4.​ ​
Edge Cases: You can discuss how to handle edge cases (e.g., negative salaries,
missing data) if asked.
5.​ ​
Scalability: You can extend this by adding features like input validation or sorting the
report.

How to Use This in an Interview

●​ Explain Your Approach: Start by walking through the problem (e.g., "First, I’ll check the
performance score, then calculate the bonus based on years of service").
●​ ​
Code Step-by-Step: Write the solution incrementally while explaining your thought
process.
●​ ​
Discuss Improvements: Mention how you could add error handling (e.g., try-except for
invalid inputs) or optimize it for larger datasets.

Scenario 1: Word Frequency Counter

Problem

You're tasked with analyzing customer feedback for a product. The company wants to know the
most frequently used words in a list of feedback comments, excluding common words like "the,"
"and," or "is." Write a Python function that takes a list of feedback strings and a list of words to
ignore, then returns a dictionary with the top 3 most frequent words and their counts.

Example Input:

python

WrapCopy

feedback = [
"The app is fast and user-friendly",
"Fast loading and great design",
"The design is sleek but slow at times",
"User-friendly app with fast performance"
]
ignore_words = ["the", "is", "and", "at", "with"]

Expected Output:

A dictionary like:

python

WrapCopy

{
"fast": 3,
"user-friendly": 2,
"design": 2
}

Solution:

python

WrapCopy

def word_frequency(feedback, ignore_words):

 # Combine all feedback into one string and convert to lowercase
combined_text = " ".join(feedback).lower()

# Replace punctuation with spaces and split into words

for char in ".,-!?":
combined_text = combined_text.replace(char, " ")
words = combined_text.split()

# Count word frequencies

word_count = {}
for word in words:
if word not in ignore_words:
word_count[word] = word_count.get(word, 0) + 1

# Sort by frequency (descending) and then alphabetically

sorted_words = sorted(word_count.items(), key=lambda x: (-x[1], x[0]))

# Return top 3 as a dictionary

return dict(sorted_words[:3])

# Test data
feedback = [
"The app is fast and user-friendly",
"Fast loading and great design",
"The design is sleek but slow at times",
"User-friendly app with fast performance"
]
ignore_words = ["the", "is", "and", "at", "with"]

# Run and display result

result = word_frequency(feedback, ignore_words)
print(result)

Output:

text

WrapCopy

{'fast': 3, 'design': 2, 'user-friendly': 2}

Interview Value:

●​ Skills Demonstrated: String manipulation, dictionary usage, sorting with custom keys
(lambda), and filtering.
●​ ​
Discussion Points: You could talk about handling edge cases (e.g., empty feedback),
optimizing for large datasets (e.g., using collections.Counter), or adding regex for better
text cleaning.
●​ ​
Relevance: Text analysis is common in data processing or NLP tasks.

Scenario 2: Recursive File System Size Calculator

Problem

Imagine you're building a tool to analyze disk usage. You're given a nested directory structure
represented as a dictionary, where each key is a folder or file name, and values are either
nested dictionaries (for folders) or integers (file sizes in KB). Write a recursive Python function to
calculate the total size of the directory.

Example Input:

python

WrapCopy

directory = {
"root": {
"folder1": {
"file1": 100,
"file2": 200
},
"folder2": {
"file3": 300
 },
"file4": 50
}

Expected Output:

text

WrapCopy

650 # Total size in KB (100 + 200 + 300 + 50)

Solution:

python

WrapCopy

def calculate_directory_size(directory):
total_size = 0

# Iterate through each item in the dictionary

for item, value in directory.items():
if isinstance(value, dict):
# If it's a folder (dictionary), recursively calculate its size
total_size += calculate_directory_size(value)
elif isinstance(value, int):
# If it's a file (integer), add its size
total_size += value

return total_size

# Test data
directory = {
"root": {
"folder1": {
"file1": 100,
 "file2": 200
},
"folder2": {
"file3": 300
},
"file4": 50
}

# Run and display result

result = calculate_directory_size(directory)
print(f"Total size: {result} KB")

Output:

text

WrapCopy

Total size: 650 KB

Interview Value:

●​ Skills Demonstrated: Recursion, type checking (isinstance), and working with nested
data structures.
●​ ​
Discussion Points: You could discuss handling invalid inputs (e.g., negative sizes),
adding error handling, or optimizing for performance with memoization if asked.
●​ ​
Relevance: Recursive problems are a staple in coding interviews, and this mimics
real-world file system traversal.

How to Leverage These in an Interview

1.​ Walk Through Logic: Explain your approach before coding (e.g., "For the word
frequency, I’ll clean the text, count words, and sort them").
2.​ ​
Show Adaptability: Be ready to modify your solution if the interviewer changes
requirements (e.g., "Return top 5 words instead" or "Add subfolder names to the
output").
3.​ ​
Highlight Python Features: Point out efficient tools like dict.get(), sorted() with key, or
recursion, showing your familiarity with the language.