Merge branch 'master' into avl_improve

Author: siriak

DIRECTORY.md

@@ -466,6 +466,7 @@
             * [SumWithoutArithmeticOperators](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/maths/SumWithoutArithmeticOperators.java)
             * [TrinomialTriangle](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/maths/TrinomialTriangle.java)
             * [TwinPrime](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/maths/TwinPrime.java)
+            * [UniformNumbers](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/maths/UniformNumbers.java)
             * [VampireNumber](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/maths/VampireNumber.java)
             * [VectorCrossProduct](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/maths/VectorCrossProduct.java)
             * [Volume](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/maths/Volume.java)
@@ -559,6 +560,7 @@
             * [NonPreemptivePriorityScheduling](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/scheduling/NonPreemptivePriorityScheduling.java)
             * [PreemptivePriorityScheduling](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/scheduling/PreemptivePriorityScheduling.java)
             * [ProportionalFairScheduling](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/scheduling/ProportionalFairScheduling.java)
+            * [RandomScheduling](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/scheduling/RandomScheduling.java)
             * [RRScheduling](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/scheduling/RRScheduling.java)
             * [SelfAdjustingScheduling](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/scheduling/SelfAdjustingScheduling.java)
             * [SJFScheduling](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/scheduling/SJFScheduling.java)
@@ -1121,6 +1123,7 @@
             * [SumWithoutArithmeticOperatorsTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/maths/SumWithoutArithmeticOperatorsTest.java)
             * [TestArmstrong](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/maths/TestArmstrong.java)
             * [TwinPrimeTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/maths/TwinPrimeTest.java)
+            * [UniformNumbersTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/maths/UniformNumbersTest.java)
             * [VolumeTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/maths/VolumeTest.java)
           * misc
             * [ColorContrastRatioTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/misc/ColorContrastRatioTest.java)
@@ -1191,6 +1194,7 @@
             * [NonPreemptivePrioritySchedulingTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/scheduling/NonPreemptivePrioritySchedulingTest.java)
             * [PreemptivePrioritySchedulingTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/scheduling/PreemptivePrioritySchedulingTest.java)
             * [ProportionalFairSchedulingTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/scheduling/ProportionalFairSchedulingTest.java)
+            * [RandomSchedulingTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/scheduling/RandomSchedulingTest.java)
             * [RRSchedulingTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/scheduling/RRSchedulingTest.java)
             * [SelfAdjustingSchedulingTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/scheduling/SelfAdjustingSchedulingTest.java)
             * [SJFSchedulingTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/scheduling/SJFSchedulingTest.java)

pom.xml

@@ -125,7 +125,7 @@
                     <dependency>
                     <groupId>com.puppycrawl.tools</groupId>
                     <artifactId>checkstyle</artifactId>
-                    <version>10.18.2</version>
+                    <version>10.19.0</version>
                     </dependency>
                 </dependencies>
             </plugin>
@@ -153,7 +153,7 @@
             <plugin>
                 <groupId>org.apache.maven.plugins</groupId>
                 <artifactId>maven-pmd-plugin</artifactId>
-                <version>3.25.0</version>
+                <version>3.26.0</version>
                 <configuration>
                     <printFailingErrors>true</printFailingErrors>
                     <includeTests>true</includeTests>

src/main/java/com/thealgorithms/maths/UniformNumbers.java

@@ -0,0 +1,50 @@
+package com.thealgorithms.maths;
+
+/**
+ * A positive integer is considered uniform if all
+ * of its digits are equal. For example, 222 is uniform,
+ * while 223 is not.
+ * Given two positive integers a and b, determine the
+ * number of uniform integers between a and b.
+ */
+public final class UniformNumbers {
+    // Private constructor to prevent instantiation of the utility class
+    private UniformNumbers() {
+        // Prevent instantiation
+    }
+    /**
+     * This function will find the number of uniform numbers
+     * from 1 to num
+     * @param num upper limit to find the uniform numbers
+     * @return the count of uniform numbers between 1 and num
+     */
+    public static int uniformNumbers(int num) {
+        String numStr = Integer.toString(num);
+        int uniformCount = (numStr.length() - 1) * 9;
+        int finalUniform = Integer.parseInt(String.valueOf(numStr.charAt(0)).repeat(numStr.length()));
+
+        if (finalUniform <= num) {
+            uniformCount += Integer.parseInt(String.valueOf(numStr.charAt(0)));
+        } else {
+            uniformCount += Integer.parseInt(String.valueOf(numStr.charAt(0))) - 1;
+        }
+
+        return uniformCount;
+    }
+    /**
+     * This function will calculate the number of uniform numbers
+     * between a and b
+     * @param a lower bound of range
+     * @param b upper bound of range
+     * @return  the count of uniform numbers between a and b
+     */
+    public static int countUniformIntegers(int a, int b) {
+        if (b > a && b > 0 && a > 0) {
+            return uniformNumbers(b) - uniformNumbers(a - 1);
+        } else if (b == a) {
+            return 1;
+        } else {
+            return 0;
+        }
+    }
+}

src/main/java/com/thealgorithms/scheduling/RandomScheduling.java

@@ -0,0 +1,45 @@
+package com.thealgorithms.scheduling;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
+import java.util.Random;
+
+/**
+ * RandomScheduling is an algorithm that assigns tasks in a random order.
+ * It doesn't consider priority, deadlines, or burst times, making it
+ * inefficient but useful in scenarios where fairness or unpredictability
+ * is required (e.g., load balancing in distributed systems).
+ *
+ * Use Case: Distributed systems where randomness helps avoid task starvation.
+ *
+ * @author Hardvan
+ */
+public final class RandomScheduling {
+
+    private final List<String> tasks;
+    private final Random random;
+
+    /**
+     * Constructs a new RandomScheduling instance.
+     *
+     * @param tasks A collection of task names to be scheduled.
+     * @param random A Random instance for generating random numbers.
+     */
+    public RandomScheduling(Collection<String> tasks, Random random) {
+        this.tasks = new ArrayList<>(tasks);
+        this.random = random;
+    }
+
+    /**
+     * Schedules the tasks randomly and returns the randomized order.
+     *
+     * @return A list representing the tasks in their randomized execution order.
+     */
+    public List<String> schedule() {
+        List<String> shuffledTasks = new ArrayList<>(tasks);
+        Collections.shuffle(shuffledTasks, random);
+        return shuffledTasks;
+    }
+}

src/test/java/com/thealgorithms/maths/UniformNumbersTest.java

@@ -0,0 +1,56 @@
+package com.thealgorithms.maths;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import org.junit.jupiter.api.Test;
+
+class UniformNumbersTest {
+
+    @Test
+    void testSingleUniformDigitRange() {
+        assertEquals(1, UniformNumbers.countUniformIntegers(1, 1));
+        assertEquals(9, UniformNumbers.countUniformIntegers(1, 9));
+    }
+
+    @Test
+    void testSmallRange() {
+        assertEquals(1, UniformNumbers.countUniformIntegers(10, 11));
+        assertEquals(2, UniformNumbers.countUniformIntegers(22, 33));
+    }
+
+    @Test
+    void testRangeWithNoUniformNumbers() {
+        assertEquals(0, UniformNumbers.countUniformIntegers(12, 21));
+        assertEquals(0, UniformNumbers.countUniformIntegers(123, 128));
+    }
+
+    @Test
+    void testRangeWithAllUniformNumbers() {
+        assertEquals(9, UniformNumbers.countUniformIntegers(1, 9));
+        assertEquals(18, UniformNumbers.countUniformIntegers(1, 99));
+    }
+
+    @Test
+    void testMultiDigitRangeWithUniformNumbers() {
+        assertEquals(1, UniformNumbers.countUniformIntegers(100, 111));
+        assertEquals(2, UniformNumbers.countUniformIntegers(111, 222));
+    }
+
+    @Test
+    void testExactUniformBoundary() {
+        assertEquals(1, UniformNumbers.countUniformIntegers(111, 111));
+        assertEquals(2, UniformNumbers.countUniformIntegers(111, 222));
+    }
+
+    @Test
+    void testLargeRange() {
+        assertEquals(27, UniformNumbers.countUniformIntegers(1, 999));
+        assertEquals(36, UniformNumbers.countUniformIntegers(1, 9999));
+    }
+
+    @Test
+    void testInvalidRange() {
+        assertEquals(0, UniformNumbers.countUniformIntegers(500, 100));
+        assertEquals(0, UniformNumbers.countUniformIntegers(-100, -1));
+    }
+}

src/test/java/com/thealgorithms/scheduling/RandomSchedulingTest.java

@@ -0,0 +1,93 @@
+package com.thealgorithms.scheduling;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.mockito.Mockito.anyInt;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+import java.util.List;
+import java.util.Random;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+public class RandomSchedulingTest {
+
+    private RandomScheduling randomScheduling;
+    private Random mockRandom;
+
+    @BeforeEach
+    public void setup() {
+        mockRandom = mock(Random.class); // Mocking Random for predictable behavior
+    }
+
+    @Test
+    public void testRandomOrder1() {
+        // Arrange
+        List<String> tasks = List.of("Task1", "Task2", "Task3");
+        // Mock the random sequence to control shuffling: swap 0 <-> 1, and 1 <-> 2.
+        when(mockRandom.nextInt(anyInt())).thenReturn(1, 2, 0);
+        randomScheduling = new RandomScheduling(tasks, mockRandom);
+
+        // Act
+        List<String> result = randomScheduling.schedule();
+
+        // Assert
+        assertEquals(List.of("Task1", "Task2", "Task3"), result);
+    }
+
+    @Test
+    public void testRandomOrder2() {
+        // Arrange
+        List<String> tasks = List.of("A", "B", "C", "D");
+        // Mocking predictable swaps for the sequence: [C, B, D, A]
+        when(mockRandom.nextInt(anyInt())).thenReturn(2, 1, 3, 0);
+        randomScheduling = new RandomScheduling(tasks, mockRandom);
+
+        // Act
+        List<String> result = randomScheduling.schedule();
+
+        // Assert
+        assertEquals(List.of("A", "C", "B", "D"), result);
+    }
+
+    @Test
+    public void testSingleTask() {
+        // Arrange
+        List<String> tasks = List.of("SingleTask");
+        when(mockRandom.nextInt(anyInt())).thenReturn(0); // No real shuffle
+        randomScheduling = new RandomScheduling(tasks, mockRandom);
+
+        // Act
+        List<String> result = randomScheduling.schedule();
+
+        // Assert
+        assertEquals(List.of("SingleTask"), result);
+    }
+
+    @Test
+    public void testEmptyTaskList() {
+        // Arrange
+        List<String> tasks = List.of();
+        randomScheduling = new RandomScheduling(tasks, mockRandom);
+
+        // Act
+        List<String> result = randomScheduling.schedule();
+
+        // Assert
+        assertEquals(List.of(), result); // Should return an empty list
+    }
+
+    @Test
+    public void testSameTasksMultipleTimes() {
+        // Arrange
+        List<String> tasks = List.of("X", "X", "Y", "Z");
+        when(mockRandom.nextInt(anyInt())).thenReturn(3, 0, 1, 2);
+        randomScheduling = new RandomScheduling(tasks, mockRandom);
+
+        // Act
+        List<String> result = randomScheduling.schedule();
+
+        // Assert
+        assertEquals(List.of("Y", "X", "X", "Z"), result);
+    }
+}