Simple vs Compound Interest Explained — Formulas, Examples & Aptitude Tricks

package io.thecodeforge.interest;

/**
 * io.thecodeforge: Simple Interest Calculator
 * Covers direct calculation, reverse engineering, and year-by-year breakdown.
 */
public class SimpleInterestCalculator {

    /**
     * Calculates Simple Interest.
     *
     * Formula: SI = (Principal × Rate × Time) / 100
     *
     * @param principal   The original sum of money (in any currency unit)
     * @param ratePerYear The annual interest rate as a percentage (e.g., 5 for 5%)
     * @param timeInYears How long the money is borrowed or invested (in years)
     * @return The simple interest earned or owed
     */
    public static double calculateSimpleInterest(
            double principal,
            double ratePerYear,
            double timeInYears) {

        // Core formula: divide by 100 because rate is given as a percentage
        double simpleInterest = (principal * ratePerYear * timeInYears) / 100;
        return simpleInterest;
    }

    /**
     * Reverse-engineer the rate when SI, P, and T are known.
     * Formula: R = (SI × 100) / (P × T)
     */
    public static double findRate(double principal, double si, double timeInYears) {
        return (si * 100) / (principal * timeInYears);
    }

    /**
     * Reverse-engineer the principal when SI, R, and T are known.
     * Formula: P = (SI × 100) / (R × T)
     */
    public static double findPrincipal(double si, double ratePerYear, double timeInYears) {
        return (si * 100) / (ratePerYear * timeInYears);
    }

    public static void main(String[] args) {

        // Scenario: Rohan borrows ₹5,000 at 8% per year for 3 years
        double principal = 5000;
        double rate      = 8;
        double time      = 3;

        double si = calculateSimpleInterest(principal, rate, time);
        double totalAmount = principal + si;

        System.out.println("===== Simple Interest Calculation =====");
        System.out.println("Principal        : ₹" + principal);
        System.out.println("Rate per year    : " + rate + "%");
        System.out.println("Time             : " + time + " years");
        System.out.println("--------------------------------------");
        System.out.println("Simple Interest  : ₹" + si);
        System.out.println("Total Amount Due : ₹" + totalAmount);

        System.out.println();

        // Year-by-year breakdown — SI adds the same amount every year
        System.out.println("===== Year-by-Year Breakdown =====");
        double yearlyInterest = principal * (rate / 100);
        for (int year = 1; year <= (int) time; year++) {
            System.out.printf("Year %d → Interest earned: ₹%.2f | Cumulative: ₹%.2f%n",
                    year, yearlyInterest, yearlyInterest * year);
        }

        System.out.println();

        // Reverse calculation demo
        double knownSI    = 1200;
        double knownP     = 5000;
        double knownT     = 3;
        double derivedRate = findRate(knownP, knownSI, knownT);
        System.out.println("===== Reverse Calculation: Find Rate =====");
        System.out.printf("If SI = ₹%.0f, P = ₹%.0f, T = %.0f yrs → Rate = %.1f%%%n",
                knownSI, knownP, knownT, derivedRate);
    }
}

package io.thecodeforge.interest;

/**
 * io.thecodeforge: Compound Interest Calculator
 * Covers annual, half-yearly, quarterly, monthly, and continuous compounding.
 * Includes year-by-year breakdown and Effective Annual Rate calculation.
 */
public class CompoundInterestCalculator {

    /**
     * Calculates Compound Interest for different compounding frequencies.
     *
     * @param principal     Original principal amount
     * @param ratePerYear   Annual rate as a percentage
     * @param timeInYears   Time in years
     * @param timesPerYear  How many times interest compounds per year
     *                      (1 = yearly, 2 = half-yearly, 4 = quarterly, 12 = monthly)
     * @return Compound interest for the given frequency
     */
    public static double calculateCI(
            double principal,
            double ratePerYear,
            double timeInYears,
            int timesPerYear) {

        double ratePerPeriod = ratePerYear / (100.0 * timesPerYear);
        double totalPeriods  = timeInYears * timesPerYear;
        double totalAmount   = principal * Math.pow(1 + ratePerPeriod, totalPeriods);
        return totalAmount - principal;
    }

    /**
     * Calculates Effective Annual Rate (EAR).
     * This is the actual annual yield when compounding happens more than once per year.
     * Formula: EAR = (1 + r/n)^n - 1
     *
     * @param ratePerYear  Stated annual rate as a percentage
     * @param timesPerYear Compounding frequency
     * @return Effective annual rate as a percentage
     */
    public static double effectiveAnnualRate(double ratePerYear, int timesPerYear) {
        double r = ratePerYear / 100.0;
        return (Math.pow(1 + r / timesPerYear, timesPerYear) - 1) * 100;
    }

    /**
     * Continuous compounding: A = P × e^(R×T)
     * The theoretical maximum compounding frequency.
     */
    public static double calculateContinuousCI(
            double principal,
            double ratePerYear,
            double timeInYears) {

        double totalAmount = principal * Math.exp(ratePerYear / 100.0 * timeInYears);
        return totalAmount - principal;
    }

    public static void main(String[] args) {

        // Scenario: Priya invests ₹10,000 at 10% for 2 years
        double principal = 10000;
        double rate      = 10;
        double time      = 2;

        double ciAnnual     = calculateCI(principal, rate, time, 1);
        double ciHalfYearly = calculateCI(principal, rate, time, 2);
        double ciQuarterly  = calculateCI(principal, rate, time, 4);
        double ciMonthly    = calculateCI(principal, rate, time, 12);
        double ciContinuous = calculateContinuousCI(principal, rate, time);

        double si = (principal * rate * time) / 100;

        System.out.println("====== Priya's Investment: ₹10,000 @ 10% for 2 Years ======");
        System.out.printf("Simple Interest (baseline)      : ₹%.2f%n", si);
        System.out.printf("Compound Interest (Yearly)      : ₹%.2f%n", ciAnnual);
        System.out.printf("Compound Interest (Half-yearly) : ₹%.2f%n", ciHalfYearly);
        System.out.printf("Compound Interest (Quarterly)   : ₹%.2f%n", ciQuarterly);
        System.out.printf("Compound Interest (Monthly)     : ₹%.2f%n", ciMonthly);
        System.out.printf("Compound Interest (Continuous)   : ₹%.2f%n", ciContinuous);

        System.out.println();

        // Effective Annual Rate comparison
        System.out.println("====== Effective Annual Rate (EAR) ======");
        System.out.printf("Stated rate: 10%% per annum%n");
        System.out.printf("  Compounded Yearly      → EAR = %.4f%%%n",
                effectiveAnnualRate(rate, 1));
        System.out.printf("  Compounded Half-yearly → EAR = %.4f%%%n",
                effectiveAnnualRate(rate, 2));
        System.out.printf("  Compounded Quarterly   → EAR = %.4f%%%n",
                effectiveAnnualRate(rate, 4));
        System.out.printf("  Compounded Monthly     → EAR = %.4f%%%n",
                effectiveAnnualRate(rate, 12));

        System.out.println();

        // Year-by-year breakdown
        System.out.println("====== Year-by-Year Breakdown (Annual CI) ======");
        double runningBalance = principal;
        for (int year = 1; year <= (int) time; year++) {
            double interestThisYear = runningBalance * (rate / 100);
            runningBalance += interestThisYear;
            System.out.printf("Year %d → Interest: ₹%.2f | Balance: ₹%.2f%n",
                    year, interestThisYear, runningBalance);
        }
    }
}

package io.thecodeforge.interest;

/**
 * io.thecodeforge: Effective Annual Rate (EAR) Comparison
 * Shows why stated rate ≠ effective rate when compounding is more frequent than annual.
 */
public class EffectiveAnnualRateDemo {

    /**
     * EAR = (1 + r/n)^n - 1
     * @param statedRatePercent  Stated annual rate (e.g., 10 for 10%)
     * @param compoundingPeriods Per year (1=annual, 4=quarterly, 12=monthly)
     * @return Effective annual rate as a percentage
     */
    public static double calculateEAR(double statedRatePercent, int compoundingPeriods) {
        double r = statedRatePercent / 100.0;
        return (Math.pow(1 + r / compoundingPeriods, compoundingPeriods) - 1) * 100;
    }

    public static void main(String[] args) {

        System.out.println("====== EAR Comparison: Same Stated Rate, Different Frequencies ======");
        double statedRate = 10;

        System.out.printf("Stated rate: %.1f%% per annum%n%n", statedRate);
        System.out.printf("  %-25s → EAR = %.4f%%%n", "Compounded Yearly",
                calculateEAR(statedRate, 1));
        System.out.printf("  %-25s → EAR = %.4f%%%n", "Compounded Half-yearly",
                calculateEAR(statedRate, 2));
        System.out.printf("  %-25s → EAR = %.4f%%%n", "Compounded Quarterly",
                calculateEAR(statedRate, 4));
        System.out.printf("  %-25s → EAR = %.4f%%%n", "Compounded Monthly",
                calculateEAR(statedRate, 12));
        System.out.printf("  %-25s → EAR = %.4f%%%n", "Compounded Daily",
                calculateEAR(statedRate, 365));

        System.out.println();

        // Real-world FD comparison
        System.out.println("====== Real-World FD Comparison (₹10,00,000 for 5 years) ======");

        double fdPrincipal = 1000000;
        double fdYears     = 5;

        double bankA_stated = 7.1;
        double bankA_ear    = calculateEAR(bankA_stated, 4); // quarterly
        double bankA_amount = fdPrincipal * Math.pow(1 + bankA_ear / 100, fdYears);

        double bankB_stated = 7.2;
        double bankB_ear    = calculateEAR(bankB_stated, 1); // annual
        double bankB_amount = fdPrincipal * Math.pow(1 + bankB_ear / 100, fdYears);

        System.out.printf("Bank A: %.1f%% compounded quarterly → EAR = %.4f%% → Maturity: ₹%.0f%n",
                bankA_stated, bankA_ear, bankA_amount);
        System.out.printf("Bank B: %.1f%% compounded annually  → EAR = %.4f%% → Maturity: ₹%.0f%n",
                bankB_stated, bankB_ear, bankB_amount);
        System.out.printf("Difference: ₹%.0f in favour of Bank A (lower stated rate wins!)%n",
                bankA_amount - bankB_amount);
    }
}

package io.thecodeforge.interest;

/**
 * io.thecodeforge: Rule of 72 — Doubling Time Calculator
 * Compares Rule of 72 approximation vs actual doubling time.
 */
public class RuleOf72Demo {

    /**
     * Rule of 72 approximation: years to double ≈ 72 / rate
     */
    public static double ruleOf72(double ratePercent) {
        return 72.0 / ratePercent;
    }

    /**
     * Actual doubling time: T = ln(2) / ln(1 + r)
     */
    public static double actualDoublingTime(double ratePercent) {
        double r = ratePercent / 100.0;
        return Math.log(2) / Math.log(1 + r);
    }

    public static void main(String[] args) {

        System.out.println("====== Rule of 72 vs Actual Doubling Time ======");
        System.out.printf("%-8s %-15s %-15s %-10s%n",
                "Rate", "Rule of 72", "Actual", "Error");
        System.out.println("------------------------------------------------------");

        double[] rates = {4, 6, 8, 10, 12, 15, 20, 36};
        for (double rate : rates) {
            double approx = ruleOf72(rate);
            double actual = actualDoublingTime(rate);
            double error  = Math.abs(approx - actual);
            System.out.printf("%-8.0f%% %-15.2f %-15.2f %-10.2f yrs%n",
                    rate, approx, actual, error);
        }

        System.out.println();

        // Retirement planning scenario
        System.out.println("====== Retirement Scenario: ₹1 Lakh at 12% for 35 Years ======");
        double investment  = 100000;
        double annualRate  = 12;
        double years       = 35;
        double doublings   = years / ruleOf72(annualRate);
        double futureValue = investment * Math.pow(2, doublings);

        System.out.printf("Initial investment : ₹%.0f%n", investment);
        System.out.printf("Annual return      : %.0f%%%n", annualRate);
        System.out.printf("Investment horizon : %.0f years%n", years);
        System.out.printf("Doubling time      : %.1f years (Rule of 72)%n",
                ruleOf72(annualRate));
        System.out.printf("Number of doublings: %.1f%n", doublings);
        System.out.printf("Future value       : ₹%.0f%n", futureValue);
        System.out.printf("(Exact calculation : ₹%.0f)%n",
                investment * Math.pow(1 + annualRate / 100, years));
    }
}

package io.thecodeforge.interest;

/**
 * io.thecodeforge: Comprehensive Aptitude Pattern Solver
 * Covers all major SI/CI question types seen in competitive exams.
 */
public class AptitudePatternSolver {

    public static void main(String[] args) {

        // ===================================================
        // TYPE 1: Find SI directly
        // Q: Find SI on ₹8,000 at 5% per annum for 4 years.
        // ===================================================
        double p1 = 8000, r1 = 5, t1 = 4;
        double si1 = (p1 * r1 * t1) / 100;
        System.out.println("TYPE 1 — Direct SI:");
        System.out.printf("SI on ₹%.0f at %.0f%% for %.0f years = ₹%.2f%n%n",
                p1, r1, t1, si1);

        // ===================================================
        // TYPE 2: Find Principal when SI is known
        // Q: SI is ₹900, Rate = 6%, Time = 5 years. Find P.
        // Formula: P = (SI × 100) / (R × T)
        // ===================================================
        double si2 = 900, r2 = 6, t2 = 5;
        double p2 = (si2 * 100) / (r2 * t2);
        System.out.println("TYPE 2 — Find Principal:");
        System.out.printf("P = (%.0f × 100) / (%.0f × %.0f) = ₹%.2f%n%n",
                si2, r2, t2, p2);

        // ===================================================
        // TYPE 3: Find Rate when SI and others are known
        // Q: P = ₹3,000, SI = ₹450, T = 3 years. Find Rate.
        // Formula: R = (SI × 100) / (P × T)
        // ===================================================
        double p3 = 3000, si3 = 450, t3 = 3;
        double r3 = (si3 * 100) / (p3 * t3);
        System.out.println("TYPE 3 — Find Rate:");
        System.out.printf("R = (%.0f × 100) / (%.0f × %.0f) = %.2f%%%n%n",
                si3, p3, t3, r3);

        // ===================================================
        // TYPE 4: CI vs SI difference shortcut (2-year)
        // Q: P = ₹20,000, R = 5%, T = 2 years. Find CI - SI.
        // Shortcut: CI - SI = P × (R/100)²
        // ===================================================
        double p4 = 20000, r4 = 5;
        double ciMinusSi = p4 * Math.pow(r4 / 100.0, 2);
        double si4 = (p4 * r4 * 2) / 100;
        double ci4 = p4 * Math.pow(1 + r4 / 100.0, 2) - p4;

        System.out.println("TYPE 4 — CI vs SI Difference (2-year shortcut):");
        System.out.printf("SI = ₹%.2f | CI = ₹%.2f | CI - SI = ₹%.2f%n",
                si4, ci4, ci4 - si4);
        System.out.printf("Shortcut P×(R/100)² = ₹%.2f → Match: %b%n%n",
                ciMinusSi, Math.abs((ci4 - si4) - ciMinusSi) < 0.001);

        // ===================================================
        // TYPE 5: Population Growth (CI in disguise)
        // Q: A town has 50,000 people. It grows at 4% per year.
        //    What will the population be after 3 years?
        // Formula: A = P(1 + R/100)^T
        // ===================================================
        double pop = 50000, popRate = 4, popTime = 3;
        double futurePopulation = pop * Math.pow(1 + popRate / 100, popTime);
        System.out.println("TYPE 5 — Population Growth:");
        System.out.printf("Current: %.0f | Rate: %.0f%% | After %.0f years: %.0f people%n%n",
                pop, popRate, popTime, futurePopulation);

        // ===================================================
        // TYPE 5b: Depreciation (negative CI)
        // Q: A car worth ₹8,00,000 depreciates at 15% per year.
        //    What is its value after 3 years?
        // Formula: A = P(1 - R/100)^T
        // ===================================================
        double carValue = 800000, depRate = 15, depTime = 3;
        double depreciatedValue = carValue * Math.pow(1 - depRate / 100, depTime);
        System.out.println("TYPE 5b — Depreciation:");
        System.out.printf("Original: ₹%.0f | Depreciation: %.0f%% | After %.0f years: ₹%.0f%n%n",
                carValue, depRate, depTime, depreciatedValue);

        // ===================================================
        // TYPE 6: Installment Problem
        // Q: A man borrows ₹20,000 at 10% CI per annum and repays
        //    in 2 equal annual installments. Find each installment.
        // Formula: I = P × r(1+r)^n / ((1+r)^n - 1)
        // ===================================================
        double loanP = 20000, loanR = 10, loanN = 2;
        double r = loanR / 100.0;
        double installment = loanP * (r * Math.pow(1 + r, loanN)) / (Math.pow(1 + r, loanN) - 1);
        double totalPaid = installment * loanN;

        System.out.println("TYPE 6 — Equal Installment Problem:");
        System.out.printf("Loan: ₹%.0f at %.0f%% CI for %.0f years%n", loanP, loanR, loanN);
        System.out.printf("Each installment: ₹%.2f%n", installment);
        System.out.printf("Total paid: ₹%.2f | Interest cost: ₹%.2f%n",
                totalPaid, totalPaid - loanP);
    }
}

package io.thecodeforge.interest;

/**
 * io.thecodeforge: Real-World Interest Impact Calculator
 * Shows how SI vs CI affects actual financial decisions.
 */
public class RealWorldImpactDemo {

    public static void main(String[] args) {

        // ===================================================
        // HOME LOAN: ₹40 lakh at 8.5% for 20 years (monthly CI)
        // ===================================================
        double homeLoanP = 4000000;
        double homeLoanR = 8.5 / 12; // monthly rate
        double homeLoanN = 20 * 12;  // total months
        double monthlyR  = homeLoanR / 100;

        // EMI formula: EMI = P × r × (1+r)^n / ((1+r)^n - 1)
        double emi = homeLoanP * monthlyR * Math.pow(1 + monthlyR, homeLoanN)
                / (Math.pow(1 + monthlyR, homeLoanN) - 1);
        double totalPaid = emi * homeLoanN;
        double interestPaid = totalPaid - homeLoanP;

        System.out.println("====== HOME LOAN: ₹40 Lakh @ 8.5% for 20 Years ======");
        System.out.printf("Monthly EMI      : ₹%.0f%n", emi);
        System.out.printf("Total paid       : ₹%.0f%n", totalPaid);
        System.out.printf("Interest paid    : ₹%.0f (more than the principal!)%n",
                interestPaid);
        System.out.printf("Interest as %% of loan: %.0f%%%n%n",
                (interestPaid / homeLoanP) * 100);

        // ===================================================
        // CREDIT CARD: ₹50,000 at 36% annual, compounded daily
        // ===================================================
        double ccPrincipal  = 50000;
        double ccRate       = 36;
        double ccDays       = 365;
        double ccDailyRate  = ccRate / (100.0 * ccDays);
        double ccTotal      = ccPrincipal * Math.pow(1 + ccDailyRate, ccDays);
        double ccInterest   = ccTotal - ccPrincipal;
        double ccEAR        = (Math.pow(1 + ccRate / (100.0 * ccDays), ccDays) - 1) * 100;

        System.out.println("====== CREDIT CARD: ₹50,000 @ 36% (Daily Compounding) ======");
        System.out.printf("Stated rate      : %.0f%% per annum%n", ccRate);
        System.out.printf("Effective rate   : %.2f%%%n", ccEAR);
        System.out.printf("After 1 year     : ₹%.0f%n", ccTotal);
        System.out.printf("Interest charged : ₹%.0f%n%n", ccInterest);

        // ===================================================
        // CAR LOAN: SI vs CI comparison on same amount
        // ===================================================
        double carLoanP = 600000;
        double carRate  = 8;
        double carTime  = 5;

        double carSI = (carLoanP * carRate * carTime) / 100;
        // CI with monthly reducing balance
        double carMonthlyR = carRate / (12.0 * 100);
        double carMonths   = carTime * 12;
        double carEMI = carLoanP * carMonthlyR * Math.pow(1 + carMonthlyR, carMonths)
                / (Math.pow(1 + carMonthlyR, carMonths) - 1);
        double carCIInterest = (carEMI * carMonths) - carLoanP;

        System.out.println("====== CAR LOAN: ₹6 Lakh @ 8% for 5 Years ======");
        System.out.printf("Flat rate (SI) interest : ₹%.0f%n", carSI);
        System.out.printf("Reducing balance (CI)   : ₹%.0f%n", carCIInterest);
        System.out.printf("Difference              : ₹%.0f (flat rate costs more!)%n",
                carSI - carCIInterest);
    }
}