Merge branch 'master' into merge_k_sorted_new_algo

Author: siriak

DIRECTORY.md

@@ -208,6 +208,7 @@
               * [PriorityQueues](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/datastructures/queues/PriorityQueues.java)
               * [Queue](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/datastructures/queues/Queue.java)
               * [QueueByTwoStacks](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/datastructures/queues/QueueByTwoStacks.java)
+              * [SlidingWindowMaximum](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/datastructures/queues/SlidingWindowMaximum.java)
               * [TokenBucket](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/datastructures/queues/TokenBucket.java)
             * stacks
               * [NodeStack](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/datastructures/stacks/NodeStack.java)
@@ -328,6 +329,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)
@@ -883,6 +885,7 @@
               * [PriorityQueuesTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/datastructures/queues/PriorityQueuesTest.java)
               * [QueueByTwoStacksTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/datastructures/queues/QueueByTwoStacksTest.java)
               * [QueueTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/datastructures/queues/QueueTest.java)
+              * [SlidingWindowMaximumTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/datastructures/queues/SlidingWindowMaximumTest.java)
               * [TokenBucketTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/datastructures/queues/TokenBucketTest.java)
             * stacks
               * [NodeStackTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/datastructures/stacks/NodeStackTest.java)
@@ -978,6 +981,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/datastructures/queues/SlidingWindowMaximum.java

@@ -0,0 +1,63 @@
+package com.thealgorithms.datastructures.queues;
+
+import java.util.Deque;
+import java.util.LinkedList;
+
+/**
+ * The {@code SlidingWindowMaximum} class provides a method to efficiently compute
+ * the maximum element within every sliding window of size {@code k} in a given array.
+ *
+ * <p>The algorithm uses a deque to maintain the indices of useful elements within
+ * the current sliding window. The time complexity of this approach is O(n) since
+ * each element is processed at most twice.
+ *
+ * @author Hardvan
+ */
+public final class SlidingWindowMaximum {
+    private SlidingWindowMaximum() {
+    }
+
+    /**
+     * Returns an array of the maximum values for each sliding window of size {@code k}.
+     * <p>If {@code nums} has fewer elements than {@code k}, the result will be an empty array.
+     * <p>Example:
+     * <pre>
+     * Input: nums = [1, 3, -1, -3, 5, 3, 6, 7], k = 3
+     * Output: [3, 3, 5, 5, 6, 7]
+     * </pre>
+     *
+     * @param nums the input array of integers
+     * @param k the size of the sliding window
+     * @return an array containing the maximum element for each sliding window
+     */
+    public static int[] maxSlidingWindow(int[] nums, int k) {
+        int n = nums.length;
+        if (n < k || k == 0) {
+            return new int[0];
+        }
+
+        int[] result = new int[n - k + 1];
+        Deque<Integer> deque = new LinkedList<>();
+        for (int i = 0; i < n; i++) {
+            // Remove elements from the front of the deque if they are out of the current window
+            if (!deque.isEmpty() && deque.peekFirst() < i - k + 1) {
+                deque.pollFirst();
+            }
+
+            // Remove elements from the back if they are smaller than the current element
+            while (!deque.isEmpty() && nums[deque.peekLast()] < nums[i]) {
+                deque.pollLast();
+            }
+
+            // Add the current element's index to the deque
+            deque.offerLast(i);
+
+            // Store the maximum element for the current window (starting from the k-1th element)
+            if (i >= k - 1) {
+                result[i - k + 1] = nums[deque.peekFirst()];
+            }
+        }
+
+        return result;
+    }
+}

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/datastructures/queues/SlidingWindowMaximumTest.java

@@ -0,0 +1,50 @@
+package com.thealgorithms.datastructures.queues;
+
+import static org.junit.jupiter.api.Assertions.assertArrayEquals;
+
+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 SlidingWindowMaximumTest {
+
+    @ParameterizedTest
+    @MethodSource("provideTestCases")
+    public void testMaxSlidingWindow(int[] nums, int k, int[] expected) {
+        assertArrayEquals(expected, SlidingWindowMaximum.maxSlidingWindow(nums, k));
+    }
+
+    private static Stream<Arguments> provideTestCases() {
+        return Stream.of(
+            // Test case 1: Example from the problem statement
+            Arguments.of(new int[] {1, 3, -1, -3, 5, 3, 6, 7}, 3, new int[] {3, 3, 5, 5, 6, 7}),
+
+            // Test case 2: All elements are the same
+            Arguments.of(new int[] {4, 4, 4, 4, 4}, 2, new int[] {4, 4, 4, 4}),
+
+            // Test case 3: Window size equals the array length
+            Arguments.of(new int[] {2, 1, 5, 3, 6}, 5, new int[] {6}),
+
+            // Test case 4: Single element array with window size 1
+            Arguments.of(new int[] {7}, 1, new int[] {7}),
+
+            // Test case 5: Window size larger than the array length
+            Arguments.of(new int[] {1, 2, 3}, 4, new int[] {}),
+
+            // Test case 6: Decreasing sequence
+            Arguments.of(new int[] {9, 8, 7, 6, 5, 4}, 3, new int[] {9, 8, 7, 6}),
+
+            // Test case 7: Increasing sequence
+            Arguments.of(new int[] {1, 2, 3, 4, 5}, 2, new int[] {2, 3, 4, 5}),
+
+            // Test case 8: k is zero
+            Arguments.of(new int[] {1, 3, -1, -3, 5, 3, 6, 7}, 0, new int[] {}),
+
+            // Test case 9: Array with negative numbers
+            Arguments.of(new int[] {-4, -2, -5, -1, -3}, 3, new int[] {-2, -1, -1}),
+
+            // Test case 10: Empty array
+            Arguments.of(new int[] {}, 3, new int[] {}));
+    }
+}

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));
+    }
+}