Merge branch 'master' into sliding_window_new_algo

Author: siriak

DIRECTORY.md

@@ -328,6 +328,7 @@
             * [StronglyConnectedComponentOptimized](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/graph/StronglyConnectedComponentOptimized.java)
           * greedyalgorithms
             * [ActivitySelection](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/greedyalgorithms/ActivitySelection.java)
+            * [BandwidthAllocation](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/greedyalgorithms/BandwidthAllocation.java)
             * [BinaryAddition](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/greedyalgorithms/BinaryAddition.java)
             * [CoinChange](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/greedyalgorithms/CoinChange.java)
             * [DigitSeparation](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/greedyalgorithms/DigitSeparation.java)
@@ -978,6 +979,7 @@
             * [StronglyConnectedComponentOptimizedTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/graph/StronglyConnectedComponentOptimizedTest.java)
           * greedyalgorithms
             * [ActivitySelectionTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/greedyalgorithms/ActivitySelectionTest.java)
+            * [BandwidthAllocationTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/greedyalgorithms/BandwidthAllocationTest.java)
             * [BinaryAdditionTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/greedyalgorithms/BinaryAdditionTest.java)
             * [CoinChangeTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/greedyalgorithms/CoinChangeTest.java)
             * [DigitSeparationTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/greedyalgorithms/DigitSeparationTest.java)

src/main/java/com/thealgorithms/conversions/AffineConverter.java

@@ -1,23 +1,64 @@
 package com.thealgorithms.conversions;
 
+/**
+ * A utility class to perform affine transformations of the form:
+ * y = slope * x + intercept.
+ *
+ * This class supports inversion and composition of affine transformations.
+ * It is immutable, meaning each instance represents a fixed transformation.
+ */
 public final class AffineConverter {
     private final double slope;
     private final double intercept;
+
+    /**
+     * Constructs an AffineConverter with the given slope and intercept.
+     *
+     * @param inSlope The slope of the affine transformation.
+     * @param inIntercept The intercept (constant term) of the affine transformation.
+     * @throws IllegalArgumentException if either parameter is NaN.
+     */
     public AffineConverter(final double inSlope, final double inIntercept) {
+        if (Double.isNaN(inSlope) || Double.isNaN(inIntercept)) {
+            throw new IllegalArgumentException("Slope and intercept must be valid numbers.");
+        }
         slope = inSlope;
         intercept = inIntercept;
     }
 
+    /**
+     * Converts the given input value using the affine transformation:
+     * result = slope * inValue + intercept.
+     *
+     * @param inValue The input value to convert.
+     * @return The transformed value.
+     */
     public double convert(final double inValue) {
         return slope * inValue + intercept;
     }
 
+    /**
+     * Returns a new AffineConverter representing the inverse of the current transformation.
+     * The inverse of y = slope * x + intercept is x = (y - intercept) / slope.
+     *
+     * @return A new AffineConverter representing the inverse transformation.
+     * @throws AssertionError if the slope is zero, as the inverse would be undefined.
+     */
     public AffineConverter invert() {
-        assert slope != 0.0;
+        assert slope != 0.0 : "Slope cannot be zero for inversion.";
         return new AffineConverter(1.0 / slope, -intercept / slope);
     }
 
+    /**
+     * Composes this affine transformation with another, returning a new AffineConverter.
+     * If this transformation is f(x) and the other is g(x), the result is f(g(x)).
+     *
+     * @param other Another AffineConverter to compose with.
+     * @return A new AffineConverter representing the composition of the two transformations.
+     */
     public AffineConverter compose(final AffineConverter other) {
-        return new AffineConverter(slope * other.slope, slope * other.intercept + intercept);
+        double newSlope = slope * other.slope;
+        double newIntercept = slope * other.intercept + intercept;
+        return new AffineConverter(newSlope, newIntercept);
     }
 }

src/main/java/com/thealgorithms/greedyalgorithms/BandwidthAllocation.java

@@ -0,0 +1,58 @@
+package com.thealgorithms.greedyalgorithms;
+
+import java.util.Arrays;
+
+/**
+ * Class to solve the Bandwidth Allocation Problem.
+ * The goal is to maximize the value gained by allocating bandwidth to users.
+ * Example:
+ * Bandwidth = 10
+ * Users = [3, 5, 7]
+ * Values = [10, 20, 30]
+ * The maximum value achievable is 40 by allocating 3 units to user 0 and 7 units to user 2.
+ *
+ * @author Hardvan
+ */
+public final class BandwidthAllocation {
+    private BandwidthAllocation() {
+    }
+
+    /**
+     * Allocates bandwidth to maximize value.
+     * Steps:
+     * 1. Calculate the ratio of value/demand for each user.
+     * 2. Sort the users in descending order of the ratio.
+     * 3. Allocate bandwidth to users in order of the sorted list.
+     * 4. If the bandwidth is not enough to allocate the full demand of a user, allocate a fraction of the demand.
+     * 5. Return the maximum value achievable.
+     *
+     * @param bandwidth total available bandwidth to allocate
+     * @param users     array of user demands
+     * @param values    array of values associated with each user's demand
+     * @return the maximum value achievable
+     */
+    public static int maxValue(int bandwidth, int[] users, int[] values) {
+        int n = users.length;
+        double[][] ratio = new double[n][2]; // {index, ratio}
+
+        for (int i = 0; i < n; i++) {
+            ratio[i][0] = i;
+            ratio[i][1] = (double) values[i] / users[i];
+        }
+
+        Arrays.sort(ratio, (a, b) -> Double.compare(b[1], a[1]));
+
+        int maxValue = 0;
+        for (int i = 0; i < n; i++) {
+            int index = (int) ratio[i][0];
+            if (bandwidth >= users[index]) {
+                maxValue += values[index];
+                bandwidth -= users[index];
+            } else {
+                maxValue += (int) (ratio[i][1] * bandwidth);
+                break;
+            }
+        }
+        return maxValue;
+    }
+}

src/test/java/com/thealgorithms/conversions/AffineConverterTest.java

@@ -16,31 +16,39 @@ void setUp() {
     }
 
     @Test
-    void testConstructor() {
+    void testConstructorWithValidValues() {
         assertEquals(3.0, converter.convert(0.0), "Expected value when input is 0.0");
         assertEquals(5.0, converter.convert(1.0), "Expected value when input is 1.0");
-        assertEquals(7.0, converter.convert(2.0), "Expected value when input is 2.0");
     }
 
     @Test
-    void testConvert() {
-        assertEquals(3.0, converter.convert(0.0), "Conversion at 0.0 should equal the intercept");
-        assertEquals(7.0, converter.convert(2.0), "2.0 should convert to 7.0");
-        assertEquals(11.0, converter.convert(4.0), "4.0 should convert to 11.0");
+    void testConstructorWithInvalidValues() {
+        assertThrows(IllegalArgumentException.class, () -> new AffineConverter(Double.NaN, 3.0), "Constructor should throw IllegalArgumentException for NaN slope");
+    }
+
+    @Test
+    void testConvertWithNegativeValues() {
+        assertEquals(-1.0, converter.convert(-2.0), "Negative input should convert correctly");
+        assertEquals(-3.0, new AffineConverter(-1.0, -1.0).convert(2.0), "Slope and intercept can be negative");
+    }
+
+    @Test
+    void testConvertWithFloatingPointPrecision() {
+        double result = new AffineConverter(1.3333, 0.6667).convert(3.0);
+        assertEquals(4.6666, result, 1e-4, "Conversion should maintain floating-point precision");
     }
 
     @Test
     void testInvert() {
         AffineConverter inverted = converter.invert();
-        assertEquals(0.0, inverted.convert(3.0), "Inverted converter should return 0.0 for input 3.0");
-        assertEquals(1.0, inverted.convert(5.0), "Inverted converter should return 1.0 for input 5.0");
-        assertEquals(2.0, inverted.convert(7.0), "Inverted converter should return 2.0 for input 7.0");
+        assertEquals(0.0, inverted.convert(3.0), "Inverted should return 0.0 for input 3.0");
+        assertEquals(1.0, inverted.convert(5.0), "Inverted should return 1.0 for input 5.0");
     }
 
     @Test
     void testInvertWithZeroSlope() {
         AffineConverter zeroSlopeConverter = new AffineConverter(0.0, 3.0);
-        assertThrows(AssertionError.class, zeroSlopeConverter::invert, "Invert should throw assertion error when slope is zero");
+        assertThrows(AssertionError.class, zeroSlopeConverter::invert, "Invert should throw AssertionError when slope is zero");
     }
 
     @Test
@@ -50,6 +58,30 @@ void testCompose() {
 
         assertEquals(7.0, composed.convert(0.0), "Expected composed conversion at 0.0");
         assertEquals(9.0, composed.convert(1.0), "Expected composed conversion at 1.0");
-        assertEquals(11.0, composed.convert(2.0), "Expected composed conversion at 2.0");
+    }
+
+    @Test
+    void testMultipleCompositions() {
+        AffineConverter c1 = new AffineConverter(2.0, 1.0);
+        AffineConverter c2 = new AffineConverter(3.0, -2.0);
+        AffineConverter c3 = c1.compose(c2); // (2x + 1) ∘ (3x - 2) => 6x - 1
+
+        assertEquals(-3.0, c3.convert(0.0), "Composed transformation should return -3.0 at 0.0");
+        assertEquals(3.0, c3.convert(1.0), "Composed transformation should return 3.0 at 1.0");
+    }
+
+    @Test
+    void testIdentityComposition() {
+        AffineConverter identity = new AffineConverter(1.0, 0.0);
+        AffineConverter composed = converter.compose(identity);
+
+        assertEquals(3.0, composed.convert(0.0), "Identity composition should not change the transformation");
+        assertEquals(7.0, composed.convert(2.0), "Identity composition should behave like the original");
+    }
+
+    @Test
+    void testLargeInputs() {
+        double largeValue = 1e6;
+        assertEquals(2.0 * largeValue + 3.0, converter.convert(largeValue), "Should handle large input values without overflow");
     }
 }

src/test/java/com/thealgorithms/greedyalgorithms/BandwidthAllocationTest.java

@@ -0,0 +1,22 @@
+package com.thealgorithms.greedyalgorithms;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import java.util.stream.Stream;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
+
+public class BandwidthAllocationTest {
+
+    @ParameterizedTest
+    @MethodSource("bandwidthProvider")
+    public void testMaxValue(int capacity, int[] bandwidths, int[] values, int expected) {
+        assertEquals(expected, BandwidthAllocation.maxValue(capacity, bandwidths, values));
+    }
+
+    private static Stream<Arguments> bandwidthProvider() {
+        return Stream.of(Arguments.of(50, new int[] {20, 10, 30}, new int[] {40, 20, 30}, 80), Arguments.of(0, new int[] {5, 10}, new int[] {10, 20}, 0), Arguments.of(5, new int[] {5, 10}, new int[] {10, 20}, 10), Arguments.of(15, new int[] {10, 20}, new int[] {10, 25}, 18),
+            Arguments.of(25, new int[] {10, 15, 20}, new int[] {10, 30, 50}, 60));
+    }
+}