Reverse Percentage Recovery — Divide Not Add Back

Percentages show up everywhere — your salary hike, your bank's interest rate, election results, discount offers, your company's growth report. If numbers describe the world, percentages are how we compare and communicate those numbers in a way every human on the planet instantly understands. That's why every aptitude test — from campus placements to UPSC to big-tech hiring rounds — opens with percentage problems. They test whether you can think proportionally under pressure, which is exactly what real business decisions demand.

The frustrating thing is that most people know what a percentage IS but freeze the moment a question twists the idea slightly — 'what is the original price after a 20% increase?' or 'by what percent is A's salary more than B's?' These aren't hard problems. They just need one clear mental model and three or four formulas that you actually understand, not just memorise.

By the end of this article you'll be able to calculate any percentage value, find the original number before a percentage change, solve percentage increase and decrease problems, handle the classic 'successive percentage change' trap, and answer the trickiest interview percentage questions without a calculator. We'll build every formula from scratch using plain English before showing you the math — because once you see where a formula comes from, you never forget it.

The Foundation: What 'Percent' Actually Means and the One Core Formula

The word 'percent' breaks into two parts: 'per' (for every) + 'cent' (hundred). So 40% simply means 40 out of every 100. Nothing more.

Here's the single formula that every percentage calculation comes from:

$$Percentage = \left( \frac{\text{Part}}{\text{Whole}} \right) \times 100$$

Flip it around and you get the two other forms you'll use constantly:

$$Part = \left( \frac{\text{Percentage}}{100} \right) \times \text{Whole}$$ $$Whole = \left( \frac{\text{Part}}{\text{Percentage}} \right) \times 100$$

Think of it as a triangle. Cover the thing you want to find — the other two pieces of the triangle tell you how to get it.

Example: In a class of 60 students, 45 passed. What percentage passed? $$Percentage = (45 / 60) \times 100 = 75\%$$

Example: 35% of what number is 84? $$Whole = (84 / 35) \times 100 = 240$$

Example: What is 15% of 340? $$Part = (15 / 100) \times 340 = 51$$

All three are the same formula, just rearranged. Burn this triangle into memory — every single percentage problem is one of these three questions in disguise.

package io.thecodeforge.aptitude;

public class PercentageFoundation {
    /**
     * Production-grade calculation for Part of a Whole
     * Standard for financial and inventory reporting
     */
    public static double calculatePart(double percentage, double whole) {
        return (percentage / 100.0) * whole;
    }

    /**
     * Calculates the Whole given a Part and its Percentage value
     * Useful for reverse-engineering totals from tax or discount values
     */
    public static double calculateWhole(double part, double percentage) {
        if (percentage == 0) throw new IllegalArgumentException("Percentage cannot be zero");
        return (part / percentage) * 100.0;
    }

    public static void main(String[] args) {
        // Example: What is 15% of 340?
        System.out.println("15% of 340 is: " + calculatePart(15, 340));
        
        // Example: 63 is 45% of what number?
        System.out.println("63 is 45% of: " + calculateWhole(63, 45));
    }
}

Percentage Increase and Decrease — The Direction Trap That Fools Everyone

This is where 80% of interview candidates slip up — not because the math is hard, but because they apply the percentage in the wrong direction.

The core formula is:

$$\text{Percentage Change} = \left( \frac{\text{New Value} - \text{Old Value}}{\text{Old Value}} \right) \times 100$$

If the result is positive → it's an increase. Negative → a decrease.

Always divide by the OLD (original) value, never the new one. That's the trap.

Now let's flip it. Suppose you know the original value and the percentage change, and you want the new value:

$$\text{New Value (Increase)} = \text{Old Value} \times (1 + R/100)$$ $$\text{New Value (Decrease)} = \text{Old Value} \times (1 - R/100)$$

The multiplier $(1 + R/100)$ or $(1 - R/100)$ is your best friend. It lets you jump straight to the answer in one step.

And if you know the new value but want the original:

$$\text{Original} = \frac{\text{New Value}}{(1 \pm R/100)}$$

This reverse-calculation is the most common 'hard question' in aptitude tests. Once you have the multiplier idea, it's just division.

package io.thecodeforge.aptitude;

public class PriceCalculator {
    /**
     * Calculates the original price before a discount was applied.
     * Crucial for 'Reverse Percentage' interview problems.
     */
    public static double findOriginalPrice(double discountedPrice, double discountPercentage) {
        double multiplier = 1 - (discountPercentage / 100.0);
        return discountedPrice / multiplier;
    }

    public static void main(String[] args) {
        // Problem: After a 20% reduction, a laptop costs 36000. Original price?
        double currentPrice = 36000;
        double discount = 20;
        double original = findOriginalPrice(currentPrice, discount);
        
        System.out.printf("Original Price: ₹%,.2f", original);
    }
}

Successive Percentage Changes — Why 10% + 10% is NOT 20%

Here's a classic interview trick: 'A value is increased by 10% and then increased again by 10%. What is the total percentage increase?' Most people say 20%. The real answer is 21%. Let's see why.

When you apply two percentage changes one after another, the second change is applied to the ALREADY-CHANGED value, not the original. So the percentages don't simply add up.

The formula for two successive percentage changes of A% and B%:

$$\text{Net \% Change} = A + B + \frac{A \times B}{100}$$

The extra term $(A \times B / 100)$ is the 'compounding effect' — the percentage of a percentage.

For three or more changes, just chain the multipliers: $$\text{Final Value} = \text{Original} \times (1 + A/100) \times (1 + B/100) \times (1 + C/100)$$

Where negative values represent decreases.

This is the secret behind why compound interest beats simple interest, why back-to-back discounts work differently than a single combined discount, and why a 50% loss followed by a 50% gain still leaves you below your starting point. Once you see the compounding pattern, these problems become straightforward.

package io.thecodeforge.aptitude;

public class CompoundingCalculator {
    /**
     * Calculates net percentage change for any number of successive changes.
     * @param originalValue Initial amount
     * @param changes Array of percentage changes (e.g., 10 for 10% inc, -5 for 5% dec)
     * @return Final value after all successive changes
     */
    public static double calculateSuccessiveChange(double originalValue, double[] changes) {
        double result = originalValue;
        for (double change : changes) {
            result *= (1 + (change / 100.0));
        }
        return result;
    }

    public static void main(String[] args) {
        double initial = 10000;
        double[] portfolioChanges = {-50, 50}; // 50% loss then 50% gain
        
        double finalValue = calculateSuccessiveChange(initial, portfolioChanges);
        System.out.println("Final Portfolio Value: ₹" + finalValue);
        System.out.println("Net Change: " + ((finalValue - initial) / initial * 100) + "%");
    }
}

Percentage Comparison Problems — 'More Than' vs 'Less Than' vs 'Of'

One of the most misread question types in aptitude tests involves comparative percentages. The difference between 'A is what percent MORE than B' and 'A is what percent OF B' is not just grammar — the answers are completely different numbers.

Here are the four question types you'll see:

Type 1 — 'A is what % of B?' Answer = $(A / B) \times 100$

Type 2 — 'A is what % more than B?' Answer = $((A - B) / B) \times 100$ (You divide by B because B is the base/reference)

Type 3 — 'A is what % less than B?' Answer = $((B - A) / B) \times 100$ (Still divide by B — it's always the reference value)

Type 4 — 'By what % should A be increased to equal B?' Answer = $((B - A) / A) \times 100$ (Now A is the base because you're changing A)

The golden rule: the denominator is always the BASE — the thing you're comparing FROM or changing FROM. Read the question carefully to identify what the 'reference' is.

This catches candidates constantly because when you're not sure, your instinct picks the wrong denominator and your answer is off.

package io.thecodeforge.aptitude;

public class ComparisonEngine {
    public static void compareSalaries(double ravi, double priya) {
        // Priya earns what % MORE than Ravi?
        double moreThan = ((priya - ravi) / ravi) * 100;
        
        // Ravi earns what % LESS than Priya?
        double lessThan = ((priya - ravi) / priya) * 100;

        System.out.printf("Priya is %.1f%% more than Ravi%n", moreThan);
        System.out.printf("Ravi is %.1f%% less than Priya%n", lessThan);
    }

    public static void main(String[] args) {
        compareSalaries(40000, 50000);
    }
}

Percentage in Data Interpretation & Compound Applications

Percentage problems aren't just isolated calculations — they appear in data interpretation tables, population growth, and depreciation problems. The same core formulas apply, but you need to chain them carefully.

Population Growth (Compound) $$\text{Population after n years} = P \times (1 + R/100)^n$$ where R is annual growth rate.

Depreciation $$\text{Value after n years} = V \times (1 - R/100)^n$$ Same structure, but with a decrease multiplier.

Data Interpretation When a table shows percentages of a total, the 'whole' often changes as you move across columns. Always identify the base: 'percentage of X' means X is the whole.

Aptitude Trick: Expenditure = Price × Consumption If price increases by 25%, to keep expenditure same, consumption must decrease by 20%. Use: % reduction = (R/(100+R))×100.

This section ties together reverse percentage, successive changes, and comparison — you'll see them in one problem frequently.

package io.thecodeforge.aptitude;

public class PopulationGrowth {
    public static double futurePopulation(double current, double growthRate, int years) {
        return current * Math.pow(1 + growthRate / 100.0, years);
    }

    public static double priceConsumptionReduction(double increasePercent) {
        // To keep expenditure same after price increase
        return (increasePercent / (100 + increasePercent)) * 100;
    }

    public static void main(String[] args) {
        double pop = futurePopulation(100000, 2.5, 5);
        System.out.println("Population after 5 years: " + pop);
        System.out.println("To offset 25% price hike, reduce consumption by: " 
            + String.format("%.1f%%", priceConsumptionReduction(25)));
    }
}