Work and Time — The Additive Rate Myth in DevOps Pipelines

# ─────────────────────────────────────────────────────────────────
# Work and Time — Core Rate Model
# TheCodeForge.io
# ─────────────────────────────────────────────────────────────────
# PROBLEM: Alice finishes a report in 10 days, Bob in 15 days.
# How long do they take working together?

from fractions import Fraction

# Step 1 — Convert durations to daily work RATES (fraction of job per day)
alice_daily_rate = Fraction(1, 10)   # Alice does 1/10 of the job each day
bob_daily_rate   = Fraction(1, 15)   # Bob does  1/15 of the job each day

# Step 2 — Combined rate is simply the sum of individual rates
# (They work in parallel, so their contributions add up each day)
combined_rate = alice_daily_rate + bob_daily_rate
print(f"Alice's daily rate : {alice_daily_rate}  (= {float(alice_daily_rate):.4f} of the job)")
print(f"Bob's daily rate   : {bob_daily_rate}  (= {float(bob_daily_rate):.4f} of the job)")
print(f"Combined daily rate: {combined_rate} (= {float(combined_rate):.4f} of the job)")

# Step 3 — Time = Total Work / Rate
# Total work is always 1 (one complete job)
total_work   = Fraction(1)
days_together = total_work / combined_rate   # 1 ÷ (1/6) = 6

print(f"\nDays to finish together: {days_together} days")
print(f"In decimal            : {float(days_together):.2f} days")

# ─────────────────────────────────────────────────────────────────
# BONUS: Verify by checking work done in 6 days
# ─────────────────────────────────────────────────────────────────
alice_work_done = alice_daily_rate * days_together
bob_work_done   = bob_daily_rate   * days_together
total_done      = alice_work_done  + bob_work_done

print(f"\nVerification:")
print(f"  Alice's share in {days_together} days: {alice_work_done}")
print(f"  Bob's share in {days_together} days  : {bob_work_done}")
print(f"  Total work done              : {total_done} ✓")  # Must equal 1

# ─────────────────────────────────────────────────────────────────
# Staged Work Problem — Worker Joins Mid-Job
# TheCodeForge.io
# ─────────────────────────────────────────────────────────────────
# PROBLEM:
#   Carlos can build a website alone in 12 days.
#   Diana can build it alone in 8 days.
#   Carlos starts alone. After some days, Diana joins.
#   They finish the rest together. Total time = 9 days.
#   How many days did Carlos work alone before Diana joined?

from fractions import Fraction

carlos_rate = Fraction(1, 12)   # Carlos completes 1/12 of the site per day
diana_rate  = Fraction(1, 8)    # Diana completes  1/8  of the site per day

total_days  = 9   # We know the project finished in 9 days total

# ── Setup ────────────────────────────────────────────────────────
# Let 'd' = number of days Carlos worked ALONE.
# Then Diana joined and they worked TOGETHER for (9 - d) days.
#
# Work done by Carlos alone  +  Work done together  =  1
#   carlos_rate * d           +  (carlos_rate + diana_rate) * (9 - d)  =  1
#
# Solve for d:

combined_rate = carlos_rate + diana_rate
print(f"Carlos daily rate  : {carlos_rate}")
print(f"Diana daily rate   : {diana_rate}")
print(f"Combined daily rate: {combined_rate}")

# Expanding the equation:
# (1/12)*d  +  (5/24)*(9 - d)  =  1
# (1/12)*d  +  (45/24) - (5/24)*d  =  1
# d*(1/12 - 5/24)  =  1 - 45/24
# d*(2/24 - 5/24)  =  24/24 - 45/24
# d*(-3/24)        =  -21/24
# d                =  (-21/24) / (-3/24)  =  7

# Let's compute it programmatically step by step
# Work equation: carlos_rate*d + combined_rate*(9-d) = 1
# => d*(carlos_rate - combined_rate) = 1 - combined_rate*9

rhs = Fraction(1) - combined_rate * total_days           # Right-hand side
lhs_coefficient = carlos_rate - combined_rate            # Coefficient of d

days_alone = rhs / lhs_coefficient
days_together = total_days - days_alone

print(f"\nCarlos worked alone for  : {days_alone} days")
print(f"Both worked together for : {days_together} days")

# ── Verification ─────────────────────────────────────────────────
work_by_carlos_alone   = carlos_rate * days_alone
work_done_together     = combined_rate * days_together
total                  = work_by_carlos_alone + work_done_together

print(f"\nVerification:")
print(f"  Work done by Carlos alone   : {work_by_carlos_alone}")
print(f"  Work done together          : {work_done_together}")
print(f"  Total                       : {total} ✓")

# ─────────────────────────────────────────────────────────────────
# Pipes and Cisterns — Inlet, Outlet and Leak Problems
# TheCodeForge.io
# ─────────────────────────────────────────────────────────────────

from fractions import Fraction

# ── PROBLEM 1: Two inlets, one outlet ────────────────────────────
# Pipe A fills the tank in 6 hours  (POSITIVE — adds water)
# Pipe B fills the tank in 4 hours  (POSITIVE — adds water)
# Pipe C drains the tank in 12 hours (NEGATIVE — removes water)
# All three are open. How long to fill an empty tank?

print("=" * 50)
print("PROBLEM 1: Two inlets + one outlet")
print("=" * 50)

pipe_a_rate =  Fraction(1, 6)    # fills 1/6 of tank per hour
pipe_b_rate =  Fraction(1, 4)    # fills 1/4 of tank per hour
pipe_c_rate = -Fraction(1, 12)   # drains 1/12 of tank per hour (NEGATIVE)

net_rate = pipe_a_rate + pipe_b_rate + pipe_c_rate
print(f"Pipe A rate : +{pipe_a_rate} per hour")
print(f"Pipe B rate : +{pipe_b_rate} per hour")
print(f"Pipe C rate : {pipe_c_rate} per hour  (drain)")
print(f"Net rate    :  {net_rate} per hour")

if net_rate > 0:
    time_to_fill = Fraction(1) / net_rate   # Total work (1 full tank) / rate
    print(f"Time to fill: {time_to_fill} hours = {float(time_to_fill):.2f} hours")
else:
    print("Tank will never fill — outlet is too fast!")


# ── PROBLEM 2: The leak problem ───────────────────────────────────
# A tank has an inlet pipe that fills it in 9 hours.
# Due to a leak at the bottom, it actually takes 12 hours to fill.
# How long would the leak alone take to empty a FULL tank?

print("\n" + "=" * 50)
print("PROBLEM 2: Finding the leak rate")
print("=" * 50)

inlet_rate      = Fraction(1, 9)    # inlet fills 1/9 per hour
net_fill_rate   = Fraction(1, 12)   # actual observed fill rate (with leak)

# net_fill_rate = inlet_rate + leak_rate
# => leak_rate  = net_fill_rate - inlet_rate   (will be negative)
leak_rate = net_fill_rate - inlet_rate
print(f"Inlet rate (fills)   : +{inlet_rate} per hour")
print(f"Observed net rate    :  {net_fill_rate} per hour")
print(f"Leak rate (drains)   :  {leak_rate} per hour")

# leak_rate is negative — take absolute value to get drain time
leak_empty_time = Fraction(1) / abs(leak_rate)
print(f"\nLeak alone empties the full tank in: {leak_empty_time} hours")


# ── PROBLEM 3: Alternate opening (open one, close other) ─────────
# Inlet fills in 3 hours. Outlet drains in 4.5 hours.
# They alternate: inlet open for first hour, outlet for second, repeat.
# How long to fill the empty tank?

print("\n" + "=" * 50)
print("PROBLEM 3: Alternating pipes")
print("=" * 50)

inlet_rate2  = Fraction(1, 3)           # fills 1/3 per hour
outlet_rate2 = Fraction(1, Fraction(9, 2))  # drains 2/9 per hour (4.5 = 9/2)

net_per_2hr_cycle = inlet_rate2 - outlet_rate2  # net fill in each 2-hour cycle
print(f"Inlet rate           : {inlet_rate2} per hour")
print(f"Outlet rate          : {outlet_rate2} per hour")
print(f"Net fill per 2hr cycle: {net_per_2hr_cycle}")

# After how many full 2-hour cycles is the tank nearly full?
tank_filled   = Fraction(0)
hours_elapsed = 0
cycle         = 0

while tank_filled < 1:
    # Hour 1 of cycle: inlet open
    tank_filled += inlet_rate2
    hours_elapsed += 1
    if tank_filled >= 1:
        break   # Tank filled during inlet hour — stop here

    # Hour 2 of cycle: outlet open
    tank_filled -= outlet_rate2
    hours_elapsed += 1
    cycle += 1

print(f"\nTank fills after     : {hours_elapsed} hours")
print(f"Full cycles completed: {cycle}")
print(f"Tank level at end    : {tank_filled} ✓")

# ─────────────────────────────────────────────────────────────────
# Efficiency Ratios and Wage Distribution
# TheCodeForge.io
# ─────────────────────────────────────────────────────────────────

from fractions import Fraction

# ── PROBLEM 1: Relative efficiency ───────────────────────────────
# Priya is 25% more efficient than Raj.
# Raj alone takes 20 days to finish a task.
# How long does Priya alone take?

print("=" * 55)
print("PROBLEM 1: Relative Efficiency")
print("=" * 55)

raj_rate   = Fraction(1, 20)                 # Raj does 1/20 per day
# Priya is 25% more efficient => her rate is 1.25x Raj's rate
priya_rate = raj_rate * Fraction(125, 100)   # Fraction avoids float errors

priya_days = Fraction(1) / priya_rate        # Time = 1 / rate
print(f"Raj's daily rate  : {raj_rate} (takes 20 days)")
print(f"Priya's daily rate: {priya_rate} (25% faster)")
print(f"Priya takes       : {priya_days} days = {float(priya_days):.1f} days")


# ── PROBLEM 2: Wage split by work contribution ────────────────────
# Emi finishes a project in 10 days. Sam finishes it in 15 days.
# They work together and earn ₹5000 total.
# How much does each person earn?

print("\n" + "=" * 55)
print("PROBLEM 2: Wage Split Proportional to Work Done")
print("=" * 55)

emi_rate  = Fraction(1, 10)
sam_rate  = Fraction(1, 15)
joint_rate = emi_rate + sam_rate
days_taken = Fraction(1) / joint_rate          # 6 days together

# Work done by each person over 6 days
emi_work_share = emi_rate * days_taken         # = 6/10 = 3/5
sam_work_share = sam_rate * days_taken         # = 6/15 = 2/5

print(f"Days taken together : {days_taken}")
print(f"Emi's work share    : {emi_work_share} of total job")
print(f"Sam's work share    : {sam_work_share} of total job")
print(f"Ratio               : {emi_work_share} : {sam_work_share}  =>  "
      f"{emi_work_share.numerator}:{sam_work_share.numerator}")

total_payment = 5000
# Wages split in ratio of work done
emi_wage = total_payment * emi_work_share
sam_wage = total_payment * sam_work_share
print(f"\nEmi earns  : ₹{emi_wage}")
print(f"Sam earns  : ₹{sam_wage}")
print(f"Total      : ₹{emi_wage + sam_wage} ✓")


# ── PROBLEM 3: Group work — simultaneous equations ────────────────
# 4 men + 6 women complete a job in 8 days.
# 3 men + 7 women complete it in 10 days.
# Find: daily rate of 1 man and 1 woman.

print("\n" + "=" * 55)
print("PROBLEM 3: Group Work (Simultaneous Equations)")
print("=" * 55)

# Let m = daily rate of 1 man,  w = daily rate of 1 woman
# Equation 1: (4m + 6w) * 8  = 1  =>  4m + 6w = 1/8
# Equation 2: (3m + 7w) * 10 = 1  =>  3m + 7w = 1/10
#
# Solve using substitution / elimination:
# From eq1: 4m = 1/8 - 6w  =>  m = (1/8 - 6w) / 4
# Substitute into eq2:

# 3 * [(1/8 - 6w)/4]  +  7w  = 1/10
# (3/8 - 18w) / 4     +  7w  = 1/10
# 3/32 - 18w/4        +  7w  = 1/10
# 3/32 - 9w/2         +  7w  = 1/10
# 3/32 + 5w/2                = 1/10
# 5w/2 = 1/10 - 3/32  = 16/160 - 15/160 = 1/160
# w    = (1/160) * (2/5) = 2/800 = 1/400

w = Fraction(1, 400)           # one woman's daily rate
m = (Fraction(1,8) - 6*w) / 4  # derived from equation 1

print(f"1 man's daily rate  : {m}  (takes {1//m} days alone)")
print(f"1 woman's daily rate: {w}  (takes {1//w} days alone)")

# Verify both original equations
assert (4*m + 6*w) * 8  == 1, "Equation 1 check failed"
assert (3*m + 7*w) * 10 == 1, "Equation 2 check failed"
print("Both group equations verified ✓")

// io.thecodeforge
// Real rate tracking, not reciprocal fantasy
public class WorkerRate {
    private final String name;
    private final double jobsPerDay; // measured, not derived

    public WorkerRate(String name, double jobsPerDay) {
        this.jobsPerDay = jobsPerDay;
    }

    // Combines rates correctly: rates add, reciprocals don't
    public static double combinedJobsPerDay(WorkerRate... workers) {
        double total = 0;
        for (WorkerRate w : workers) total += w.jobsPerDay;
        return total;
    }

    public static void main(String[] args) {
        WorkerRate alice = new WorkerRate("Alice", 0.05); // 20 days per job
        WorkerRate bob = new WorkerRate("Bob", 0.067);    // ~15 days per job
        double combined = combinedJobsPerDay(alice, bob);
        System.out.printf("Combined rate: %.3f jobs/day%n", combined);
        System.out.printf("Time for 1 job: %.2f days%n", 1.0 / combined);
    }
}

// io.thecodeforge
// Realistic team estimation, not linear extrapolation
import java.util.*;

public class TeamVelocity {
    private final int headcount;
    private final double overheadFactor; // 0.0 to 1.0, fraction of time lost to coordination

    public TeamVelocity(int headcount, double overheadFactor) {
        this.headcount = headcount;
        this.overheadFactor = overheadFactor;
    }

    public double effectiveVelocity(double baseVelocityPerPerson) {
        double raw = headcount * baseVelocityPerPerson;
        double overhead = raw * overheadFactor * (headcount - 1); // O(n^2) overhead
        return Math.max(0, raw - overhead);
    }

    public static void main(String[] args) {
        // Adding a 4th person when overhead is 10% per channel
        TeamVelocity team3 = new TeamVelocity(3, 0.10);
        TeamVelocity team4 = new TeamVelocity(4, 0.10);
        double vel3 = team3.effectiveVelocity(1.0); // 1 job/day per person base
        double vel4 = team4.effectiveVelocity(1.0);
        System.out.printf("Team of 3: %.2f jobs/day%n", vel3);
        System.out.printf("Team of 4: %.2f jobs/day%n", vel4);
        System.out.printf("Gain from +1 person: %.2f jobs/day (not 1.0)%n", vel4 - vel3);
    }
}

// io.thecodeforge
// State-dependent pipe rates, not simple subtraction
public class CisternSimulator {
    private double fillRate;    // liters/min
    private double drainRate;   // liters/min
    private double level;       // current liters

    public CisternSimulator(double fillRate, double drainRate, double initialLevel) {
        this.fillRate = fillRate;
        this.drainRate = drainRate;
        this.level = initialLevel;
    }

    public void tick(double minutes) {
        // Drain rate depends on level: can't drain if empty
        double actualDrain = (level > 0) ? drainRate : 0;
        // Fill rate stops if cistern overflows (san check)
        double actualFill = fillRate;
        double net = (actualFill - actualDrain) * minutes;
        level = Math.max(0, Math.min(100, level + net));
    }

    public double getLevel() { return level; }

    public static void main(String[] args) {
        CisternSimulator cs = new CisternSimulator(5.0, 7.0, 50.0);
        for (int m = 0; m < 30; m++) {
            cs.tick(1.0);
            System.out.printf("Minute %d: level %.1f L%n", m+1, cs.getLevel());
            if (cs.getLevel() <= 0) {
                System.out.println("Cistern empty. Drain stalls.");
                break;
            }
        }
    }
}

def alternate_days_time(rate_a, rate_b, pattern):
    # pattern: 'alternate' means A works odd days, B works even days
    # rates are per day
    work_done = 0
    day = 1
    while work_done < 1:
        if day % 2 == 1:
            work_done += rate_a
        else:
            work_done += rate_b
        day += 1
    return day - 1

print(alternate_days_time(1/10, 1/15, 'alternate'))  # Output: 12

def time_from_efficiency(efficiencies, combined_time):
    # efficiencies: list of ratios (e.g., [2,3,5])
    # combined_time: time taken together
    total_eff = sum(efficiencies)
    rates = [e / (total_eff * combined_time) for e in efficiencies]
    times = [1/r for r in rates]
    return times

print(time_from_efficiency([2,3,5], 10))  # Output: [50.0, 33.33, 20.0]

import math

def fraction_method(times):
    rates = [1/t for t in times]
    combined_rate = sum(rates)
    return 1 / combined_rate

def lcm_method(times):
    lcm = 1
    for t in times:
        lcm = lcm * t // math.gcd(lcm, t)
    work_per_day = [lcm // t for t in times]
    total_per_day = sum(work_per_day)
    return lcm / total_per_day

print(fraction_method([10, 15]))  # 6.0
print(lcm_method([10, 15]))       # 6.0