Calculate Amount Paid in Taxes - Practice Coding Problems

Calculate Amount Paid in Taxes - Problem

Array Simulation Easy

Calculate Your Tax Bill

Imagine you're a tax accountant working for a financial consulting firm. Your job is to calculate exactly how much tax someone owes based on a progressive tax system.

You are given a brackets array where each element [upper_bound, tax_rate] represents a tax bracket. The brackets are sorted by upper bound, and taxes are calculated in a tiered system:

💰 The first upper₀ dollars are taxed at percent₀%
💰 The next (upper₁ - upper₀) dollars are taxed at percent₁%
💰 The next (upper₂ - upper₁) dollars are taxed at percent₂%
💰 And so on...

Goal: Given someone's total income, calculate the total amount of tax they need to pay.

Example: If brackets are [[3,50], [7,10], [12,25]] and income is 10:
• First $3 taxed at 50% = $1.50
• Next $(7-3) = $4 taxed at 10% = $0.40
• Next $(10-7) = $3 taxed at 25% = $0.75
• Total tax = $1.50 + $0.40 + $0.75 = $2.65

Input & Output

example_1.py — Basic Tax Calculation

$ Input: brackets = [[3,50],[7,10],[12,25]], income = 10

› Output: 2.65000

💡 Note: First $3 taxed at 50% = $1.50, next $4 (7-3) taxed at 10% = $0.40, remaining $3 (10-7) taxed at 25% = $0.75. Total = $2.65

example_2.py — Income Fits in First Bracket

$ Input: brackets = [[1,0],[4,25],[5,50]], income = 2

› Output: 0.25000

💡 Note: First $1 taxed at 0% = $0.00, next $1 (2-1) taxed at 25% = $0.25. Total = $0.25

example_3.py — High Income Spanning All Brackets

$ Input: brackets = [[2,10],[5,20],[10,30]], income = 15

› Output: 4.00000

💡 Note: First $2 at 10% = $0.20, next $3 at 20% = $0.60, next $5 at 30% = $1.50, remaining $5 at 30% = $1.50. Total = $3.80

Visualization

Tap to expand

Understanding the Visualization

Setup

Income of $10 needs to flow through 3 tax brackets with rates 50%, 10%, and 25%

First Bracket

$3 flows through first bracket at 50% rate → Tax: $1.50

Second Bracket

Remaining $7, but only $4 fits in this bracket at 10% → Tax: $0.40

Third Bracket

Final $3 flows through last bracket at 25% rate → Tax: $0.75

Key Takeaway

🎯 Key Insight: Process income sequentially through each tax bracket, calculating tax only on the portion that fits within each bracket's range. This simulates the real-world progressive tax system efficiently in O(n) time.

Time & Space Complexity

Time Complexity

⏱️

O(n)

We iterate through each tax bracket once, where n is the number of brackets

✓ Linear Growth

Space Complexity

O(1)

We only use a constant amount of extra space for variables

✓ Linear Space

Constraints

1 ≤ brackets.length ≤ 100
1 ≤ upper_i ≤ 1000
0 ≤ percent_i ≤ 100
0 ≤ income ≤ 1000
brackets is sorted in ascending order by upper_i
All the values of upper_i are unique

Asked in

f Meta 15 a Amazon 12 G Google 8 ⊞ Microsoft 6

The optimal solution uses a single-pass simulation approach. We iterate through each tax bracket sequentially, calculating the tax for the portion of income that falls within each bracket's range. The key insight is to track the remaining income and previous upper bound to determine how much income gets taxed at each rate. Time complexity is O(n) where n is the number of tax brackets.

Common Approaches

Approach	Time	Space	Notes
✓ Simulation Approach	O(n)	O(1)	Iterate through each tax bracket and calculate tax for the portion of income in that bracket

Simulation Approach — Algorithm Steps

Initialize total tax to 0 and track remaining income
For each tax bracket, determine the taxable amount in that bracket
Calculate tax for that portion: min(remaining_income, bracket_width) × tax_rate
Add to total tax and reduce remaining income
Continue until all income is processed or no income remains

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Start with total income and zero tax

Process Bracket 1

Tax first $3 at 50% rate

Process Bracket 2

Tax next $4 at 10% rate

Process Bracket 3

Tax remaining $3 at 25% rate

Code -

solution.c — C

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

double calculateTax(int brackets[][2], int numBrackets, int income) {
    double totalTax = 0.0;
    int remainingIncome = income;
    int prevUpper = 0;
    
    for (int i = 0; i < numBrackets; i++) {
        if (remainingIncome <= 0) break;
        
        int upper = brackets[i][0];
        int percent = brackets[i][1];
        
        // Calculate taxable amount in this bracket
        int bracketWidth = upper - prevUpper;
        int taxableInBracket = (remainingIncome < bracketWidth) ? remainingIncome : bracketWidth;
        
        // Calculate tax for this bracket
        double taxInBracket = taxableInBracket * (percent / 100.0);
        totalTax += taxInBracket;
        
        // Update remaining income and previous upper bound
        remainingIncome -= taxableInBracket;
        prevUpper = upper;
    }
    
    return totalTax;
}

int main() {
    int brackets[][2] = {{3,50},{7,10},{12,25}};
    int income = 10;
    printf("%.5f\n", calculateTax(brackets, 3, income));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

We iterate through each tax bracket once, where n is the number of brackets

✓ Linear Growth

Space Complexity

O(1)

We only use a constant amount of extra space for variables

✓ Linear Space

Constraints

1 ≤ brackets.length ≤ 100
1 ≤ upper_i ≤ 1000
0 ≤ percent_i ≤ 100
0 ≤ income ≤ 1000
brackets is sorted in ascending order by upper_i
All the values of upper_i are unique

26.5K Views

Medium Frequency

~15 min Avg. Time

892 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

Calculate Your Tax Bill

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Simulation Approach — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler