From 9b5ced457c6e1e78c5d958a7b0d7ccc678f773c5 Mon Sep 17 00:00:00 2001
From: mjk22071998 <mjk22071998@gmail.com>
Date: Wed, 2 Oct 2024 16:37:49 +0500
Subject: [PATCH 01/43] Sorted Linked List added with Javadoc and tests

---
 .../lists/SortedLinkedList.java               | 161 ++++++++++++++++++
 .../lists/SortedlinkedListTest.java           |  88 ++++++++++
 2 files changed, 249 insertions(+)
 create mode 100644 src/main/java/com/thealgorithms/datastructures/lists/SortedLinkedList.java
 create mode 100644 src/test/java/com/thealgorithms/datastructures/lists/SortedlinkedListTest.java

diff --git a/src/main/java/com/thealgorithms/datastructures/lists/SortedLinkedList.java b/src/main/java/com/thealgorithms/datastructures/lists/SortedLinkedList.java
new file mode 100644
index 000000000000..2090fa505061
--- /dev/null
+++ b/src/main/java/com/thealgorithms/datastructures/lists/SortedLinkedList.java
@@ -0,0 +1,161 @@
+package com.thealgorithms.datastructures.lists;
+
+import java.util.ArrayList;
+
+/**
+ * A SortedLinkedList is a data structure that maintains a sorted list of elements.
+ * Elements are ordered based on their natural ordering or by a Comparator provided at the time of creation.
+ *
+ * @author Muhammad Junaid Khalid
+ * @param int the type of elements in this list
+ */
+
+public class SortedLinkedList {
+    private Node head;
+    private Node tail;
+
+    public SortedLinkedList(){
+        this.head=null;
+        this.tail=null;
+    }
+
+    /**
+     * Inserts a new element into the sorted linked list.
+     * 
+     * @param value the value to be inserted
+     */
+    public void insert(int value){
+        Node newNode = new Node(value);
+        if (head == null) {
+            this.head = newNode;
+            this.tail = newNode;
+        }
+        else if (value < head.value) {
+            newNode.next = this.head;
+            this.head = newNode;
+        } 
+        else if (value > tail.value) {
+            this.tail.next = newNode;
+        }
+        else{
+            Node temp=head;
+            while (temp.next != null && temp.next.value < value) {
+                temp = temp.next;
+            }
+            newNode.next = temp.next;
+            temp.next = newNode;
+        }
+    }
+
+    /**
+     * Displays the elements of the sorted linked list.
+     */
+    public void display(){
+        System.out.println(this.toString());
+    }
+
+    /**
+     * Deletes the first occurrence of the specified element in the sorted linked list.
+     * 
+     * @param value the value to be deleted
+     * @return true if the element is found and deleted, false otherwise
+     */
+    public boolean delete(int value){
+        if (this.head == null) {
+            return false;
+        }
+        else if (this.head.value == value) {
+            this.head = this.head.next;
+            return true;
+        }
+        else{
+            Node temp = this.head;
+            while (temp.next != null) {
+                if (temp.next.value == value) {
+                    temp.next = temp.next.next;
+                    return true;
+                }
+                temp = temp.next;
+            }
+            return  false;
+
+        }
+    }
+
+    /**
+     * Searches for the specified element in the sorted linked list.
+     * 
+     * @param value the value to be searched
+     * @return true if the element is found, false otherwise
+     */
+    public boolean search(int value){
+        Node temp = this.head;
+        while (temp != null) {
+            if (temp.value == value) {
+                return true;
+            }
+            temp = temp.next;
+        }
+        return false;
+    }
+
+    /**
+     * Checks if the sorted linked list is empty.
+     * 
+     * @return true if the list is empty, false otherwise
+     */
+    public boolean isEmpty() {
+        return head == null;
+    }
+
+    /**
+     * Returns the minimum value in the sorted linked list.
+     * 
+     * @return the minimum value
+     */
+    public int minValue(){
+        return this.head.value;
+    }
+
+    /**
+     * Returns the maximum value in the sorted linked list.
+     * 
+     * @return the maximum value
+     */
+    public int maxValue(){
+        return this.tail.value;
+    }
+
+    /**
+     * Returns a string representation of the sorted linked list.
+     * 
+     * @return a string representation of the sorted linked list
+     */
+    @Override
+    public String toString() {
+        ArrayList<String> elements=new ArrayList<>();
+        Node temp = this.head;
+        while (temp != null) {
+            elements.add(String.valueOf(temp.value));
+            temp = temp.next;
+        }
+        return String.join(", ", elements);
+    }
+    
+
+    public class Node {
+        public int value;
+        public Node next;
+
+        public Node(){
+            this.value = 0;
+            this.next= null;
+        }
+
+        public Node(int value){
+            this.value = value;
+            this.next = null;
+        }
+
+    }
+}
diff --git a/src/test/java/com/thealgorithms/datastructures/lists/SortedlinkedListTest.java b/src/test/java/com/thealgorithms/datastructures/lists/SortedlinkedListTest.java
new file mode 100644
index 000000000000..f12294767466
--- /dev/null
+++ b/src/test/java/com/thealgorithms/datastructures/lists/SortedlinkedListTest.java
@@ -0,0 +1,88 @@
+package com.thealgorithms.datastructures.lists;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+import org.junit.Test;
+
+public class SortedLinkedListTest {
+    
+    @Test
+    public void testInsert() {
+        SortedLinkedList list = new SortedLinkedList();
+        list.insert(5);
+        list.insert(3);
+        list.insert(7);
+        assertEquals("3, 5, 7", list.toString());
+    }
+
+    @Test
+    public void testDelete() {
+        SortedLinkedList list = new SortedLinkedList();
+        list.insert(5);
+        list.insert(3);
+        list.insert(7);
+        assertTrue(list.delete(5));
+        assertEquals("3, 7", list.toString());
+        assertFalse(list.delete(10));
+    }
+
+    @Test
+    public void testSearch() {
+        SortedLinkedList list = new SortedLinkedList();
+        list.insert(5);
+        list.insert(3);
+        list.insert(7);
+        assertTrue(list.search(5));
+        assertFalse(list.search(10));
+    }
+
+    @Test
+    public void testMinValue() {
+        SortedLinkedList list = new SortedLinkedList();
+        list.insert(5);
+        list.insert(3);
+        list.insert(7);
+        assertEquals(3, list.minValue());
+    }
+
+    @Test
+    public void testMaxValue() {
+        SortedLinkedList list = new SortedLinkedList();
+        list.insert(5);
+        list.insert(3);
+        list.insert(7);
+        assertEquals(7, list.maxValue());
+    }
+
+    @Test
+    public void testEmptyList() {
+        SortedLinkedList list = new SortedLinkedList();
+        assertEquals("", list.toString());
+        assertFalse(list.delete(5));
+        assertFalse(list.search(5));
+        assertEquals(0, list.minValue());
+        assertEquals(0, list.maxValue());
+    }
+    @Test
+    public void testIsEmpty_onEmptyList() {
+        SortedLinkedList list = new SortedLinkedList();
+        assertTrue(list.isEmpty());
+    }
+
+    @Test
+    public void testIsEmpty_onNonEmptyList() {
+        SortedLinkedList list = new SortedLinkedList();
+        list.insert(10);
+        assertFalse(list.isEmpty());
+    }
+
+    @Test
+    public void testIsEmpty_afterDeletion() {
+        SortedLinkedList list = new SortedLinkedList();
+        list.insert(10);
+        list.delete(10);
+        assertTrue(list.isEmpty());
+    }
+}

From e1382c1ac040f03e1497957a1799b542ba9b0827 Mon Sep 17 00:00:00 2001
From: mjk22071998 <mjk22071998@gmail.com>
Date: Wed, 2 Oct 2024 16:49:14 +0500
Subject: [PATCH 02/43] "Added comments to SortedLinkedList.java to describe
 the implementation and provide a reference link."

---
 .../thealgorithms/datastructures/lists/SortedLinkedList.java | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/src/main/java/com/thealgorithms/datastructures/lists/SortedLinkedList.java b/src/main/java/com/thealgorithms/datastructures/lists/SortedLinkedList.java
index 2090fa505061..bde6a97de84a 100644
--- a/src/main/java/com/thealgorithms/datastructures/lists/SortedLinkedList.java
+++ b/src/main/java/com/thealgorithms/datastructures/lists/SortedLinkedList.java
@@ -5,7 +5,10 @@
 /**
  * A SortedLinkedList is a data structure that maintains a sorted list of elements.
  * Elements are ordered based on their natural ordering or by a Comparator provided at the time of creation.
- *
+ * This implementation uses a singly linked list to store the elements.
+ * Further details can be found on this link
+ * https://runestone.academy/ns/books/published/cppds/LinearLinked/ImplementinganOrderedList.html
+ * 
  * @author Muhammad Junaid Khalid
  * @param int the type of elements in this list
  */

From 3ec762783b4e3a96ba686e6c1771de17e834b2f7 Mon Sep 17 00:00:00 2001
From: mjk22071998 <mjk22071998@gmail.com>
Date: Wed, 2 Oct 2024 16:56:07 +0500
Subject: [PATCH 03/43] Upgraded test from junit 4 to junit 5

---
 .../datastructures/lists/SortedlinkedListTest.java        | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/test/java/com/thealgorithms/datastructures/lists/SortedlinkedListTest.java b/src/test/java/com/thealgorithms/datastructures/lists/SortedlinkedListTest.java
index f12294767466..5c19cd078b5d 100644
--- a/src/test/java/com/thealgorithms/datastructures/lists/SortedlinkedListTest.java
+++ b/src/test/java/com/thealgorithms/datastructures/lists/SortedlinkedListTest.java
@@ -1,10 +1,10 @@
 package com.thealgorithms.datastructures.lists;
 
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 public class SortedLinkedListTest {
     

From 6ff74f0ea33e0df179e3c99404a8ad0ebc158710 Mon Sep 17 00:00:00 2001
From: mjk22071998 <mjk22071998@gmail.com>
Date: Wed, 2 Oct 2024 17:02:53 +0500
Subject: [PATCH 04/43] Added space before braces of functions

---
 .../datastructures/lists/SortedLinkedList.java | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/src/main/java/com/thealgorithms/datastructures/lists/SortedLinkedList.java b/src/main/java/com/thealgorithms/datastructures/lists/SortedLinkedList.java
index bde6a97de84a..018329253518 100644
--- a/src/main/java/com/thealgorithms/datastructures/lists/SortedLinkedList.java
+++ b/src/main/java/com/thealgorithms/datastructures/lists/SortedLinkedList.java
@@ -17,7 +17,7 @@ public class SortedLinkedList {
     private Node head;
     private Node tail;
 
-    public SortedLinkedList(){
+    public SortedLinkedList() {
         this.head=null;
         this.tail=null;
     }
@@ -27,7 +27,7 @@ public SortedLinkedList(){
      * 
      * @param value the value to be inserted
      */
-    public void insert(int value){
+    public void insert(int value) {
         Node newNode = new Node(value);
         if (head == null) {
             this.head = newNode;
@@ -53,7 +53,7 @@ else if (value > tail.value) {
     /**
      * Displays the elements of the sorted linked list.
      */
-    public void display(){
+    public void display() {
         System.out.println(this.toString());
     }
 
@@ -63,7 +63,7 @@ public void display(){
      * @param value the value to be deleted
      * @return true if the element is found and deleted, false otherwise
      */
-    public boolean delete(int value){
+    public boolean delete(int value) {
         if (this.head == null) {
             return false;
         }
@@ -91,7 +91,7 @@ else if (this.head.value == value) {
      * @param value the value to be searched
      * @return true if the element is found, false otherwise
      */
-    public boolean search(int value){
+    public boolean search(int value) {
         Node temp = this.head;
         while (temp != null) {
             if (temp.value == value) {
@@ -116,7 +116,7 @@ public boolean isEmpty() {
      * 
      * @return the minimum value
      */
-    public int minValue(){
+    public int minValue() {
         return this.head.value;
     }
 
@@ -125,7 +125,7 @@ public int minValue(){
      * 
      * @return the maximum value
      */
-    public int maxValue(){
+    public int maxValue() {
         return this.tail.value;
     }
 
@@ -150,12 +150,12 @@ public class Node {
         public int value;
         public Node next;
 
-        public Node(){
+        public Node() {
             this.value = 0;
             this.next= null;
         }
 
-        public Node(int value){
+        public Node(int value) {
             this.value = value;
             this.next = null;
         }

From dd91a15949be35a10cd8916af9d76a100ebf3369 Mon Sep 17 00:00:00 2001
From: Muhammad Junaid Khalid <mjk22071998@gmail.com>
Date: Wed, 2 Oct 2024 17:07:24 +0500
Subject: [PATCH 05/43] Rename SortedlinkedListTest.java to
 SortedLinkedListTest.java

---
 .../{SortedlinkedListTest.java => SortedLinkedListTest.java}      | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename src/test/java/com/thealgorithms/datastructures/lists/{SortedlinkedListTest.java => SortedLinkedListTest.java} (100%)

diff --git a/src/test/java/com/thealgorithms/datastructures/lists/SortedlinkedListTest.java b/src/test/java/com/thealgorithms/datastructures/lists/SortedLinkedListTest.java
similarity index 100%
rename from src/test/java/com/thealgorithms/datastructures/lists/SortedlinkedListTest.java
rename to src/test/java/com/thealgorithms/datastructures/lists/SortedLinkedListTest.java

From 2c33f89f132560af95602a3c2c506f812f1fbb8b Mon Sep 17 00:00:00 2001
From: mjk22071998 <mjk22071998@gmail.com>
Date: Wed, 2 Oct 2024 17:12:08 +0500
Subject: [PATCH 06/43] made to string null safe

---
 .../lists/SortedLinkedList.java               | 25 +++++++++++--------
 1 file changed, 15 insertions(+), 10 deletions(-)

diff --git a/src/main/java/com/thealgorithms/datastructures/lists/SortedLinkedList.java b/src/main/java/com/thealgorithms/datastructures/lists/SortedLinkedList.java
index 018329253518..59c34fdc021f 100644
--- a/src/main/java/com/thealgorithms/datastructures/lists/SortedLinkedList.java
+++ b/src/main/java/com/thealgorithms/datastructures/lists/SortedLinkedList.java
@@ -18,8 +18,8 @@ public class SortedLinkedList {
     private Node tail;
 
     public SortedLinkedList() {
-        this.head=null;
-        this.tail=null;
+        this.head = null;
+        this.tail = null;
     }
 
     /**
@@ -41,7 +41,7 @@ else if (value > tail.value) {
             this.tail.next = newNode;
         }
         else{
-            Node temp=head;
+            Node temp = head;
             while (temp.next != null && temp.next.value < value) {
                 temp = temp.next;
             }
@@ -136,13 +136,18 @@ public int maxValue() {
      */
     @Override
     public String toString() {
-        ArrayList<String> elements=new ArrayList<>();
-        Node temp = this.head;
-        while (temp != null) {
-            elements.add(String.valueOf(temp.value));
-            temp = temp.next;
+        if (this.head != null) {
+            ArrayList<String> elements=new ArrayList<>();
+            Node temp = this.head;
+            while (temp != null) {
+                elements.add(String.valueOf(temp.value));
+                temp = temp.next;
+            }
+            return String.join(", ", elements);
+        }
+        else {
+            return "";
         }
-        return String.join(", ", elements);
     }
     
 
@@ -152,7 +157,7 @@ public class Node {
 
         public Node() {
             this.value = 0;
-            this.next= null;
+            this.next = null;
         }
 
         public Node(int value) {

From 58390c1d9c47fa7b2a2f6160e160664050d66bb7 Mon Sep 17 00:00:00 2001
From: mjk22071998 <mjk22071998@gmail.com>
Date: Wed, 2 Oct 2024 17:32:15 +0500
Subject: [PATCH 07/43] Updated tail

---
 .../datastructures/lists/SortedLinkedList.java  | 17 ++++++++++++++---
 1 file changed, 14 insertions(+), 3 deletions(-)

diff --git a/src/main/java/com/thealgorithms/datastructures/lists/SortedLinkedList.java b/src/main/java/com/thealgorithms/datastructures/lists/SortedLinkedList.java
index 59c34fdc021f..948e533f085b 100644
--- a/src/main/java/com/thealgorithms/datastructures/lists/SortedLinkedList.java
+++ b/src/main/java/com/thealgorithms/datastructures/lists/SortedLinkedList.java
@@ -47,6 +47,9 @@ else if (value > tail.value) {
             }
             newNode.next = temp.next;
             temp.next = newNode;
+            if (newNode.next==null){
+                this.tail=newNode;
+            }
         }
     }
 
@@ -63,25 +66,33 @@ public void display() {
      * @param value the value to be deleted
      * @return true if the element is found and deleted, false otherwise
      */
-    public boolean delete(int value) {
+    public boolean delete(int value){
         if (this.head == null) {
             return false;
         }
         else if (this.head.value == value) {
-            this.head = this.head.next;
+            if (this.head.next == null) {
+                this.head = null;
+                this.tail = null;
+            } else {
+                this.head = this.head.next;
+            }
             return true;
         }
         else{
             Node temp = this.head;
             while (temp.next != null) {
                 if (temp.next.value == value) {
+                    if (temp.next == this.tail) {
+                        this.tail = temp;
+                    }
                     temp.next = temp.next.next;
                     return true;
                 }
                 temp = temp.next;
             }
             return  false;
-
+    
         }
     }
 

From 028727f19366d58b5bb4db83072bd7a1e06a3e1c Mon Sep 17 00:00:00 2001
From: mjk22071998 <mjk22071998@gmail.com>
Date: Wed, 2 Oct 2024 17:38:06 +0500
Subject: [PATCH 08/43] "Added assignment of `this.tail` to `newNode` in
 `SortedLinkedList` class."

---
 .../com/thealgorithms/datastructures/lists/SortedLinkedList.java | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/main/java/com/thealgorithms/datastructures/lists/SortedLinkedList.java b/src/main/java/com/thealgorithms/datastructures/lists/SortedLinkedList.java
index 948e533f085b..837697cd23f7 100644
--- a/src/main/java/com/thealgorithms/datastructures/lists/SortedLinkedList.java
+++ b/src/main/java/com/thealgorithms/datastructures/lists/SortedLinkedList.java
@@ -39,6 +39,7 @@ else if (value < head.value) {
         } 
         else if (value > tail.value) {
             this.tail.next = newNode;
+            this.tail = newNode;
         }
         else{
             Node temp = head;

From 3dce7f0ff797dad43181b8b10f64dafbf6252914 Mon Sep 17 00:00:00 2001
From: mjk22071998 <mjk22071998@gmail.com>
Date: Wed, 2 Oct 2024 17:48:52 +0500
Subject: [PATCH 09/43] Remove assertions for minValue and maxValue in empty
 list test

---
 .../datastructures/lists/SortedLinkedListTest.java              | 2 --
 1 file changed, 2 deletions(-)

diff --git a/src/test/java/com/thealgorithms/datastructures/lists/SortedLinkedListTest.java b/src/test/java/com/thealgorithms/datastructures/lists/SortedLinkedListTest.java
index 5c19cd078b5d..9c4a185c5155 100644
--- a/src/test/java/com/thealgorithms/datastructures/lists/SortedLinkedListTest.java
+++ b/src/test/java/com/thealgorithms/datastructures/lists/SortedLinkedListTest.java
@@ -62,8 +62,6 @@ public void testEmptyList() {
         assertEquals("", list.toString());
         assertFalse(list.delete(5));
         assertFalse(list.search(5));
-        assertEquals(0, list.minValue());
-        assertEquals(0, list.maxValue());
     }
     @Test
     public void testIsEmpty_onEmptyList() {

From 9e0cdf3135967e59e5cc77f7ebb4bc19b1c0543d Mon Sep 17 00:00:00 2001
From: mjk22071998 <mjk22071998@gmail.com>
Date: Wed, 2 Oct 2024 17:56:57 +0500
Subject: [PATCH 10/43] tried to get link updated

---
 .../lists/SortedLinkedList.java               | 31 +++++--------------
 1 file changed, 8 insertions(+), 23 deletions(-)

diff --git a/src/main/java/com/thealgorithms/datastructures/lists/SortedLinkedList.java b/src/main/java/com/thealgorithms/datastructures/lists/SortedLinkedList.java
index 837697cd23f7..12a40e18d696 100644
--- a/src/main/java/com/thealgorithms/datastructures/lists/SortedLinkedList.java
+++ b/src/main/java/com/thealgorithms/datastructures/lists/SortedLinkedList.java
@@ -8,7 +8,6 @@
  * This implementation uses a singly linked list to store the elements.
  * Further details can be found on this link
  * https://runestone.academy/ns/books/published/cppds/LinearLinked/ImplementinganOrderedList.html
- * 
  * @author Muhammad Junaid Khalid
  * @param int the type of elements in this list
  */
@@ -24,7 +23,6 @@ public SortedLinkedList() {
 
     /**
      * Inserts a new element into the sorted linked list.
-     * 
      * @param value the value to be inserted
      */
     public void insert(int value) {
@@ -32,16 +30,13 @@ public void insert(int value) {
         if (head == null) {
             this.head = newNode;
             this.tail = newNode;
-        }
-        else if (value < head.value) {
+        } else if (value < head.value) {
             newNode.next = this.head;
             this.head = newNode;
-        } 
-        else if (value > tail.value) {
+        } else if (value > tail.value) {
             this.tail.next = newNode;
             this.tail = newNode;
-        }
-        else{
+        } else {
             Node temp = head;
             while (temp.next != null && temp.next.value < value) {
                 temp = temp.next;
@@ -63,15 +58,13 @@ public void display() {
 
     /**
      * Deletes the first occurrence of the specified element in the sorted linked list.
-     * 
      * @param value the value to be deleted
      * @return true if the element is found and deleted, false otherwise
      */
-    public boolean delete(int value){
+    public boolean delete(int value) {
         if (this.head == null) {
             return false;
-        }
-        else if (this.head.value == value) {
+        } else if (this.head.value == value) {
             if (this.head.next == null) {
                 this.head = null;
                 this.tail = null;
@@ -79,8 +72,7 @@ else if (this.head.value == value) {
                 this.head = this.head.next;
             }
             return true;
-        }
-        else{
+        } else{
             Node temp = this.head;
             while (temp.next != null) {
                 if (temp.next.value == value) {
@@ -93,13 +85,11 @@ else if (this.head.value == value) {
                 temp = temp.next;
             }
             return  false;
-    
         }
     }
 
     /**
      * Searches for the specified element in the sorted linked list.
-     * 
      * @param value the value to be searched
      * @return true if the element is found, false otherwise
      */
@@ -116,7 +106,6 @@ public boolean search(int value) {
 
     /**
      * Checks if the sorted linked list is empty.
-     * 
      * @return true if the list is empty, false otherwise
      */
     public boolean isEmpty() {
@@ -125,7 +114,6 @@ public boolean isEmpty() {
 
     /**
      * Returns the minimum value in the sorted linked list.
-     * 
      * @return the minimum value
      */
     public int minValue() {
@@ -134,7 +122,6 @@ public int minValue() {
 
     /**
      * Returns the maximum value in the sorted linked list.
-     * 
      * @return the maximum value
      */
     public int maxValue() {
@@ -143,21 +130,19 @@ public int maxValue() {
 
     /**
      * Returns a string representation of the sorted linked list.
-     * 
      * @return a string representation of the sorted linked list
      */
     @Override
     public String toString() {
         if (this.head != null) {
-            ArrayList<String> elements=new ArrayList<>();
+            ArrayList<String> elements = new ArrayList<>();
             Node temp = this.head;
             while (temp != null) {
                 elements.add(String.valueOf(temp.value));
                 temp = temp.next;
             }
             return String.join(", ", elements);
-        }
-        else {
+        } else {
             return "";
         }
     }

From 1c2bb10dfbd27639627741a2f4fe97b5a3c2fa1b Mon Sep 17 00:00:00 2001
From: mjk22071998 <mjk22071998@gmail.com>
Date: Wed, 2 Oct 2024 18:05:02 +0500
Subject: [PATCH 11/43] "Fixed whitespace and formatting issues in
 SortedLinkedList.java and SortedLinkedListTest.java"

---
 .../datastructures/lists/SortedLinkedList.java             | 7 +++----
 .../datastructures/lists/SortedLinkedListTest.java         | 6 +++---
 2 files changed, 6 insertions(+), 7 deletions(-)

diff --git a/src/main/java/com/thealgorithms/datastructures/lists/SortedLinkedList.java b/src/main/java/com/thealgorithms/datastructures/lists/SortedLinkedList.java
index 12a40e18d696..0f084ca0e87a 100644
--- a/src/main/java/com/thealgorithms/datastructures/lists/SortedLinkedList.java
+++ b/src/main/java/com/thealgorithms/datastructures/lists/SortedLinkedList.java
@@ -43,8 +43,8 @@ public void insert(int value) {
             }
             newNode.next = temp.next;
             temp.next = newNode;
-            if (newNode.next==null){
-                this.tail=newNode;
+            if (newNode.next == null) {
+                this.tail = newNode;
             }
         }
     }
@@ -72,7 +72,7 @@ public boolean delete(int value) {
                 this.head = this.head.next;
             }
             return true;
-        } else{
+        } else {
             Node temp = this.head;
             while (temp.next != null) {
                 if (temp.next.value == value) {
@@ -146,7 +146,6 @@ public String toString() {
             return "";
         }
     }
-    
 
     public class Node {
         public int value;
diff --git a/src/test/java/com/thealgorithms/datastructures/lists/SortedLinkedListTest.java b/src/test/java/com/thealgorithms/datastructures/lists/SortedLinkedListTest.java
index 9c4a185c5155..53f1faf5ff69 100644
--- a/src/test/java/com/thealgorithms/datastructures/lists/SortedLinkedListTest.java
+++ b/src/test/java/com/thealgorithms/datastructures/lists/SortedLinkedListTest.java
@@ -64,20 +64,20 @@ public void testEmptyList() {
         assertFalse(list.search(5));
     }
     @Test
-    public void testIsEmpty_onEmptyList() {
+    public void testIsEmptyOnEmptyList() {
         SortedLinkedList list = new SortedLinkedList();
         assertTrue(list.isEmpty());
     }
 
     @Test
-    public void testIsEmpty_onNonEmptyList() {
+    public void testIsEmptyOnNonEmptyList() {
         SortedLinkedList list = new SortedLinkedList();
         list.insert(10);
         assertFalse(list.isEmpty());
     }
 
     @Test
-    public void testIsEmpty_afterDeletion() {
+    public void testIsEmptyAfterDeletion() {
         SortedLinkedList list = new SortedLinkedList();
         list.insert(10);
         list.delete(10);

From 25be88e4a9b958cd8715da86019131731fb04b3a Mon Sep 17 00:00:00 2001
From: mjk22071998 <mjk22071998@gmail.com>
Date: Wed, 2 Oct 2024 18:09:29 +0500
Subject: [PATCH 12/43] formatting of test file corrected

---
 .../datastructures/lists/SortedLinkedListTest.java              | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/test/java/com/thealgorithms/datastructures/lists/SortedLinkedListTest.java b/src/test/java/com/thealgorithms/datastructures/lists/SortedLinkedListTest.java
index 53f1faf5ff69..8d130a9731c0 100644
--- a/src/test/java/com/thealgorithms/datastructures/lists/SortedLinkedListTest.java
+++ b/src/test/java/com/thealgorithms/datastructures/lists/SortedLinkedListTest.java
@@ -7,7 +7,7 @@
 import org.junit.jupiter.api.Test;
 
 public class SortedLinkedListTest {
-    
+
     @Test
     public void testInsert() {
         SortedLinkedList list = new SortedLinkedList();

From 0a5495d07c2c07974bb4663c3cde606697dee0c7 Mon Sep 17 00:00:00 2001
From: mjk22071998 <mjk22071998@gmail.com>
Date: Wed, 2 Oct 2024 18:22:08 +0500
Subject: [PATCH 13/43] Removed few whitespaces

---
 .../thealgorithms/datastructures/lists/SortedLinkedList.java   | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/src/main/java/com/thealgorithms/datastructures/lists/SortedLinkedList.java b/src/main/java/com/thealgorithms/datastructures/lists/SortedLinkedList.java
index 0f084ca0e87a..57bf9d1ff3ff 100644
--- a/src/main/java/com/thealgorithms/datastructures/lists/SortedLinkedList.java
+++ b/src/main/java/com/thealgorithms/datastructures/lists/SortedLinkedList.java
@@ -84,7 +84,7 @@ public boolean delete(int value) {
                 }
                 temp = temp.next;
             }
-            return  false;
+            return false;
         }
     }
 
@@ -160,6 +160,5 @@ public Node(int value) {
             this.value = value;
             this.next = null;
         }
-
     }
 }

From 16cdb6012253588f1d67bb395c8ac0079e77bd04 Mon Sep 17 00:00:00 2001
From: mjk22071998 <mjk22071998@gmail.com>
Date: Thu, 3 Oct 2024 05:45:44 +0500
Subject: [PATCH 14/43] Addressed comments by alxkm

---
 .../lists/SortedLinkedList.java               | 27 +++----------------
 .../lists/SortedLinkedListTest.java           | 19 -------------
 2 files changed, 4 insertions(+), 42 deletions(-)

diff --git a/src/main/java/com/thealgorithms/datastructures/lists/SortedLinkedList.java b/src/main/java/com/thealgorithms/datastructures/lists/SortedLinkedList.java
index 57bf9d1ff3ff..81f12d83bb10 100644
--- a/src/main/java/com/thealgorithms/datastructures/lists/SortedLinkedList.java
+++ b/src/main/java/com/thealgorithms/datastructures/lists/SortedLinkedList.java
@@ -1,6 +1,7 @@
 package com.thealgorithms.datastructures.lists;
 
 import java.util.ArrayList;
+import java.util.List;
 
 /**
  * A SortedLinkedList is a data structure that maintains a sorted list of elements.
@@ -8,10 +9,7 @@
  * This implementation uses a singly linked list to store the elements.
  * Further details can be found on this link
  * https://runestone.academy/ns/books/published/cppds/LinearLinked/ImplementinganOrderedList.html
- * @author Muhammad Junaid Khalid
- * @param int the type of elements in this list
  */
-
 public class SortedLinkedList {
     private Node head;
     private Node tail;
@@ -111,23 +109,6 @@ public boolean search(int value) {
     public boolean isEmpty() {
         return head == null;
     }
-
-    /**
-     * Returns the minimum value in the sorted linked list.
-     * @return the minimum value
-     */
-    public int minValue() {
-        return this.head.value;
-    }
-
-    /**
-     * Returns the maximum value in the sorted linked list.
-     * @return the maximum value
-     */
-    public int maxValue() {
-        return this.tail.value;
-    }
-
     /**
      * Returns a string representation of the sorted linked list.
      * @return a string representation of the sorted linked list
@@ -135,7 +116,7 @@ public int maxValue() {
     @Override
     public String toString() {
         if (this.head != null) {
-            ArrayList<String> elements = new ArrayList<>();
+            List<String> elements = new ArrayList<>();
             Node temp = this.head;
             while (temp != null) {
                 elements.add(String.valueOf(temp.value));
@@ -147,8 +128,8 @@ public String toString() {
         }
     }
 
-    public class Node {
-        public int value;
+    public final class Node {
+        public final int value;
         public Node next;
 
         public Node() {
diff --git a/src/test/java/com/thealgorithms/datastructures/lists/SortedLinkedListTest.java b/src/test/java/com/thealgorithms/datastructures/lists/SortedLinkedListTest.java
index 8d130a9731c0..7bc5006a9433 100644
--- a/src/test/java/com/thealgorithms/datastructures/lists/SortedLinkedListTest.java
+++ b/src/test/java/com/thealgorithms/datastructures/lists/SortedLinkedListTest.java
@@ -37,25 +37,6 @@ public void testSearch() {
         assertTrue(list.search(5));
         assertFalse(list.search(10));
     }
-
-    @Test
-    public void testMinValue() {
-        SortedLinkedList list = new SortedLinkedList();
-        list.insert(5);
-        list.insert(3);
-        list.insert(7);
-        assertEquals(3, list.minValue());
-    }
-
-    @Test
-    public void testMaxValue() {
-        SortedLinkedList list = new SortedLinkedList();
-        list.insert(5);
-        list.insert(3);
-        list.insert(7);
-        assertEquals(7, list.maxValue());
-    }
-
     @Test
     public void testEmptyList() {
         SortedLinkedList list = new SortedLinkedList();

From 90c97828f81d6b712dee67f2a73a593c4b7ace96 Mon Sep 17 00:00:00 2001
From: mjk22071998 <mjk22071998@gmail.com>
Date: Thu, 3 Oct 2024 10:29:59 +0500
Subject: [PATCH 15/43] "Updated toString method to include brackets and
 removed default Node constructor."

---
 .../datastructures/lists/SortedLinkedList.java         | 10 +++-------
 1 file changed, 3 insertions(+), 7 deletions(-)

diff --git a/src/main/java/com/thealgorithms/datastructures/lists/SortedLinkedList.java b/src/main/java/com/thealgorithms/datastructures/lists/SortedLinkedList.java
index 81f12d83bb10..4cf782679b7c 100644
--- a/src/main/java/com/thealgorithms/datastructures/lists/SortedLinkedList.java
+++ b/src/main/java/com/thealgorithms/datastructures/lists/SortedLinkedList.java
@@ -122,9 +122,10 @@ public String toString() {
                 elements.add(String.valueOf(temp.value));
                 temp = temp.next;
             }
-            return String.join(", ", elements);
+            return "[" + String.join(", ", elements) + "]";
+
         } else {
-            return "";
+            return "[]";
         }
     }
 
@@ -132,11 +133,6 @@ public final class Node {
         public final int value;
         public Node next;
 
-        public Node() {
-            this.value = 0;
-            this.next = null;
-        }
-
         public Node(int value) {
             this.value = value;
             this.next = null;

From ebc8d33fe7796c0cef3c04ccf5d401362d6de8fd Mon Sep 17 00:00:00 2001
From: mjk22071998 <mjk22071998@gmail.com>
Date: Thu, 3 Oct 2024 10:34:33 +0500
Subject: [PATCH 16/43] tests updated

---
 .../datastructures/lists/SortedLinkedListTest.java          | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/test/java/com/thealgorithms/datastructures/lists/SortedLinkedListTest.java b/src/test/java/com/thealgorithms/datastructures/lists/SortedLinkedListTest.java
index 7bc5006a9433..4877e6db4ec4 100644
--- a/src/test/java/com/thealgorithms/datastructures/lists/SortedLinkedListTest.java
+++ b/src/test/java/com/thealgorithms/datastructures/lists/SortedLinkedListTest.java
@@ -14,7 +14,7 @@ public void testInsert() {
         list.insert(5);
         list.insert(3);
         list.insert(7);
-        assertEquals("3, 5, 7", list.toString());
+        assertEquals("[3, 5, 7]", list.toString());
     }
 
     @Test
@@ -24,7 +24,7 @@ public void testDelete() {
         list.insert(3);
         list.insert(7);
         assertTrue(list.delete(5));
-        assertEquals("3, 7", list.toString());
+        assertEquals("[3, 7]", list.toString());
         assertFalse(list.delete(10));
     }
 
@@ -40,7 +40,7 @@ public void testSearch() {
     @Test
     public void testEmptyList() {
         SortedLinkedList list = new SortedLinkedList();
-        assertEquals("", list.toString());
+        assertEquals("[]", list.toString());
         assertFalse(list.delete(5));
         assertFalse(list.search(5));
     }

From 073be5ae0152ebc6aa6e440154c6fdbca6504225 Mon Sep 17 00:00:00 2001
From: mjk22071998 <mjk22071998@gmail.com>
Date: Thu, 3 Oct 2024 14:13:54 +0500
Subject: [PATCH 17/43] Digit Separation algorithm added for positive numbers

---
 .../DigitSeparationPositiveNumber.java        | 40 ++++++++++++
 .../DigitSeparationPositiveNumberTest.java    | 64 +++++++++++++++++++
 2 files changed, 104 insertions(+)
 create mode 100644 src/main/java/com/thealgorithms/greedyalgorithms/DigitSeparationPositiveNumber.java
 create mode 100644 src/test/java/com/thealgorithms/greedyalgorithms/DigitSeparationPositiveNumberTest.java

diff --git a/src/main/java/com/thealgorithms/greedyalgorithms/DigitSeparationPositiveNumber.java b/src/main/java/com/thealgorithms/greedyalgorithms/DigitSeparationPositiveNumber.java
new file mode 100644
index 000000000000..df4159f96ddf
--- /dev/null
+++ b/src/main/java/com/thealgorithms/greedyalgorithms/DigitSeparationPositiveNumber.java
@@ -0,0 +1,40 @@
+package com.thealgorithms.greedyalgorithms;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+/**
+ * This class provides methods to separate the digits of a large positive number into a list.
+ */
+public class DigitSeparationPositiveNumber {
+    public DigitSeparationPositiveNumber() {
+    }
+    /**
+     * Separates the digits of a large positive number into a list in reverse order.
+     * @param largeNumber The large number to separate digits from.
+     * @return A list of digits in reverse order.
+     */
+    public List<Long> digitSeparationReverseOrder(long largeNumber) {
+        List<Long> result = new ArrayList<>();
+        if (largeNumber!=0) {
+            while (largeNumber > 0) {
+                result.add(largeNumber%10);
+                largeNumber = largeNumber/10;
+            }
+        } else {
+            result.add(0L);
+        }
+        return result;
+    }
+    /**
+     * Separates the digits of a large positive number into a list in forward order.
+     * @param largeNumber The large number to separate digits from.
+     * @return A list of digits in forward order.
+     */
+    public List<Long> digitSeparationForwardOrder(long largeNumber) {
+        List<Long> result = this.digitSeparationReverseOrder(largeNumber);
+        Collections.reverse(result);
+        return result;
+    }
+}
diff --git a/src/test/java/com/thealgorithms/greedyalgorithms/DigitSeparationPositiveNumberTest.java b/src/test/java/com/thealgorithms/greedyalgorithms/DigitSeparationPositiveNumberTest.java
new file mode 100644
index 000000000000..75c48262051e
--- /dev/null
+++ b/src/test/java/com/thealgorithms/greedyalgorithms/DigitSeparationPositiveNumberTest.java
@@ -0,0 +1,64 @@
+package com.thealgorithms.greedyalgorithms;
+
+import org.junit.jupiter.api.Test;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import java.util.List;
+
+public class DigitSeparationPositiveNumberTest {
+
+    @Test
+    public void testDigitSeparationReverseOrder_SingleDigit() {
+        DigitSeparationPositiveNumber digitSeparation = new DigitSeparationPositiveNumber();
+        List<Long> result = digitSeparation.digitSeparationReverseOrder(5);
+        assertEquals(List.of(5L), result);
+    }
+
+    @Test
+    public void testDigitSeparationReverseOrderMultipleDigits() {
+        DigitSeparationPositiveNumber digitSeparation = new DigitSeparationPositiveNumber();
+        List<Long> result = digitSeparation.digitSeparationReverseOrder(123);
+        assertEquals(List.of(3L, 2L, 1L), result);
+    }
+
+    @Test
+    public void testDigitSeparationReverseOrderLargeNumber() {
+        DigitSeparationPositiveNumber digitSeparation = new DigitSeparationPositiveNumber();
+        List<Long> result = digitSeparation.digitSeparationReverseOrder(123456789);
+        assertEquals(List.of(9L, 8L, 7L, 6L, 5L, 4L, 3L, 2L, 1L), result);
+    }
+
+    @Test
+    public void testDigitSeparationReverseOrderZero() {
+        DigitSeparationPositiveNumber digitSeparation = new DigitSeparationPositiveNumber();
+        List<Long> result = digitSeparation.digitSeparationReverseOrder(0);
+        assertEquals(List.of(0L), result);
+    }
+
+    @Test
+    public void testDigitSeparationForwardOrderSingleDigit() {
+        DigitSeparationPositiveNumber digitSeparation = new DigitSeparationPositiveNumber();
+        List<Long> result = digitSeparation.digitSeparationForwardOrder(5);
+        assertEquals(List.of(5L), result);
+    }
+
+    @Test
+    public void testDigitSeparationForwardOrderMultipleDigits() {
+        DigitSeparationPositiveNumber digitSeparation = new DigitSeparationPositiveNumber();
+        List<Long> result = digitSeparation.digitSeparationForwardOrder(123);
+        assertEquals(List.of(1L, 2L, 3L), result);
+    }
+
+    @Test
+    public void testDigitSeparationForwardOrderLargeNumber() {
+        DigitSeparationPositiveNumber digitSeparation = new DigitSeparationPositiveNumber();
+        List<Long> result = digitSeparation.digitSeparationForwardOrder(123456789);
+        assertEquals(List.of(1L, 2L, 3L, 4L, 5L, 6L, 7L, 8L, 9L), result);
+    }
+
+    @Test
+    public void testDigitSeparationForwardOrderZero() {
+        DigitSeparationPositiveNumber digitSeparation = new DigitSeparationPositiveNumber();
+        List<Long> result = digitSeparation.digitSeparationForwardOrder(0);
+        assertEquals(List.of(0L), result);
+    }
+}

From f6452c24368af501d940ac71b13171217e4654db Mon Sep 17 00:00:00 2001
From: mjk22071998 <mjk22071998@gmail.com>
Date: Thu, 3 Oct 2024 14:26:02 +0500
Subject: [PATCH 18/43] Renamed files

---
 ...ositiveNumber.java => DigitSeparation.java} |  4 ++--
 ...umberTest.java => DigitSeparationTest.java} | 18 +++++++++---------
 2 files changed, 11 insertions(+), 11 deletions(-)
 rename src/main/java/com/thealgorithms/greedyalgorithms/{DigitSeparationPositiveNumber.java => DigitSeparation.java} (93%)
 rename src/test/java/com/thealgorithms/greedyalgorithms/{DigitSeparationPositiveNumberTest.java => DigitSeparationTest.java} (70%)

diff --git a/src/main/java/com/thealgorithms/greedyalgorithms/DigitSeparationPositiveNumber.java b/src/main/java/com/thealgorithms/greedyalgorithms/DigitSeparation.java
similarity index 93%
rename from src/main/java/com/thealgorithms/greedyalgorithms/DigitSeparationPositiveNumber.java
rename to src/main/java/com/thealgorithms/greedyalgorithms/DigitSeparation.java
index df4159f96ddf..88356d1be68c 100644
--- a/src/main/java/com/thealgorithms/greedyalgorithms/DigitSeparationPositiveNumber.java
+++ b/src/main/java/com/thealgorithms/greedyalgorithms/DigitSeparation.java
@@ -7,8 +7,8 @@
 /**
  * This class provides methods to separate the digits of a large positive number into a list.
  */
-public class DigitSeparationPositiveNumber {
-    public DigitSeparationPositiveNumber() {
+public class DigitSeparation {
+    public DigitSeparation() {
     }
     /**
      * Separates the digits of a large positive number into a list in reverse order.
diff --git a/src/test/java/com/thealgorithms/greedyalgorithms/DigitSeparationPositiveNumberTest.java b/src/test/java/com/thealgorithms/greedyalgorithms/DigitSeparationTest.java
similarity index 70%
rename from src/test/java/com/thealgorithms/greedyalgorithms/DigitSeparationPositiveNumberTest.java
rename to src/test/java/com/thealgorithms/greedyalgorithms/DigitSeparationTest.java
index 75c48262051e..1cd7a05afee9 100644
--- a/src/test/java/com/thealgorithms/greedyalgorithms/DigitSeparationPositiveNumberTest.java
+++ b/src/test/java/com/thealgorithms/greedyalgorithms/DigitSeparationTest.java
@@ -4,60 +4,60 @@
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import java.util.List;
 
-public class DigitSeparationPositiveNumberTest {
+public class DigitSeparationTest {
 
     @Test
     public void testDigitSeparationReverseOrder_SingleDigit() {
-        DigitSeparationPositiveNumber digitSeparation = new DigitSeparationPositiveNumber();
+        DigitSeparation digitSeparation = new DigitSeparation();
         List<Long> result = digitSeparation.digitSeparationReverseOrder(5);
         assertEquals(List.of(5L), result);
     }
 
     @Test
     public void testDigitSeparationReverseOrderMultipleDigits() {
-        DigitSeparationPositiveNumber digitSeparation = new DigitSeparationPositiveNumber();
+        DigitSeparation digitSeparation = new DigitSeparation();
         List<Long> result = digitSeparation.digitSeparationReverseOrder(123);
         assertEquals(List.of(3L, 2L, 1L), result);
     }
 
     @Test
     public void testDigitSeparationReverseOrderLargeNumber() {
-        DigitSeparationPositiveNumber digitSeparation = new DigitSeparationPositiveNumber();
+        DigitSeparation digitSeparation = new DigitSeparation();
         List<Long> result = digitSeparation.digitSeparationReverseOrder(123456789);
         assertEquals(List.of(9L, 8L, 7L, 6L, 5L, 4L, 3L, 2L, 1L), result);
     }
 
     @Test
     public void testDigitSeparationReverseOrderZero() {
-        DigitSeparationPositiveNumber digitSeparation = new DigitSeparationPositiveNumber();
+        DigitSeparation digitSeparation = new DigitSeparation();
         List<Long> result = digitSeparation.digitSeparationReverseOrder(0);
         assertEquals(List.of(0L), result);
     }
 
     @Test
     public void testDigitSeparationForwardOrderSingleDigit() {
-        DigitSeparationPositiveNumber digitSeparation = new DigitSeparationPositiveNumber();
+        DigitSeparation digitSeparation = new DigitSeparation();
         List<Long> result = digitSeparation.digitSeparationForwardOrder(5);
         assertEquals(List.of(5L), result);
     }
 
     @Test
     public void testDigitSeparationForwardOrderMultipleDigits() {
-        DigitSeparationPositiveNumber digitSeparation = new DigitSeparationPositiveNumber();
+        DigitSeparation digitSeparation = new DigitSeparation();
         List<Long> result = digitSeparation.digitSeparationForwardOrder(123);
         assertEquals(List.of(1L, 2L, 3L), result);
     }
 
     @Test
     public void testDigitSeparationForwardOrderLargeNumber() {
-        DigitSeparationPositiveNumber digitSeparation = new DigitSeparationPositiveNumber();
+        DigitSeparation digitSeparation = new DigitSeparation();
         List<Long> result = digitSeparation.digitSeparationForwardOrder(123456789);
         assertEquals(List.of(1L, 2L, 3L, 4L, 5L, 6L, 7L, 8L, 9L), result);
     }
 
     @Test
     public void testDigitSeparationForwardOrderZero() {
-        DigitSeparationPositiveNumber digitSeparation = new DigitSeparationPositiveNumber();
+        DigitSeparation digitSeparation = new DigitSeparation();
         List<Long> result = digitSeparation.digitSeparationForwardOrder(0);
         assertEquals(List.of(0L), result);
     }

From 15faa54de3338f58d5a8bb884246834506e3ec0c Mon Sep 17 00:00:00 2001
From: mjk22071998 <mjk22071998@gmail.com>
Date: Thu, 3 Oct 2024 14:31:25 +0500
Subject: [PATCH 19/43] linter errors resolved

---
 .../com/thealgorithms/greedyalgorithms/DigitSeparation.java | 6 +++---
 .../thealgorithms/greedyalgorithms/DigitSeparationTest.java | 1 +
 2 files changed, 4 insertions(+), 3 deletions(-)

diff --git a/src/main/java/com/thealgorithms/greedyalgorithms/DigitSeparation.java b/src/main/java/com/thealgorithms/greedyalgorithms/DigitSeparation.java
index 88356d1be68c..628dadcffa61 100644
--- a/src/main/java/com/thealgorithms/greedyalgorithms/DigitSeparation.java
+++ b/src/main/java/com/thealgorithms/greedyalgorithms/DigitSeparation.java
@@ -17,10 +17,10 @@ public DigitSeparation() {
      */
     public List<Long> digitSeparationReverseOrder(long largeNumber) {
         List<Long> result = new ArrayList<>();
-        if (largeNumber!=0) {
+        if (largeNumber != 0) {
             while (largeNumber > 0) {
-                result.add(largeNumber%10);
-                largeNumber = largeNumber/10;
+                result.add(largeNumber % 10);
+                largeNumber = largeNumber / 10;
             }
         } else {
             result.add(0L);
diff --git a/src/test/java/com/thealgorithms/greedyalgorithms/DigitSeparationTest.java b/src/test/java/com/thealgorithms/greedyalgorithms/DigitSeparationTest.java
index 1cd7a05afee9..d5c204b833a8 100644
--- a/src/test/java/com/thealgorithms/greedyalgorithms/DigitSeparationTest.java
+++ b/src/test/java/com/thealgorithms/greedyalgorithms/DigitSeparationTest.java
@@ -2,6 +2,7 @@
 
 import org.junit.jupiter.api.Test;
 import static org.junit.jupiter.api.Assertions.assertEquals;
+
 import java.util.List;
 
 public class DigitSeparationTest {

From 278b3d01849146c40035c6a8a50e5bb0b7ee8f1f Mon Sep 17 00:00:00 2001
From: mjk22071998 <mjk22071998@gmail.com>
Date: Thu, 3 Oct 2024 14:36:35 +0500
Subject: [PATCH 20/43] linter styles corrected

---
 .../thealgorithms/greedyalgorithms/DigitSeparationTest.java  | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/src/test/java/com/thealgorithms/greedyalgorithms/DigitSeparationTest.java b/src/test/java/com/thealgorithms/greedyalgorithms/DigitSeparationTest.java
index d5c204b833a8..78ec47091839 100644
--- a/src/test/java/com/thealgorithms/greedyalgorithms/DigitSeparationTest.java
+++ b/src/test/java/com/thealgorithms/greedyalgorithms/DigitSeparationTest.java
@@ -1,14 +1,13 @@
 package com.thealgorithms.greedyalgorithms;
 
-import org.junit.jupiter.api.Test;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 
 import java.util.List;
-
+import org.junit.jupiter.api.Test;
 public class DigitSeparationTest {
 
     @Test
-    public void testDigitSeparationReverseOrder_SingleDigit() {
+    public void testDigitSeparationReverseOrderSingleDigit() {
         DigitSeparation digitSeparation = new DigitSeparation();
         List<Long> result = digitSeparation.digitSeparationReverseOrder(5);
         assertEquals(List.of(5L), result);

From 44b985e4a26950cfa39dbcd8c325a764a8a99cd3 Mon Sep 17 00:00:00 2001
From: mjk22071998 <mjk22071998@gmail.com>
Date: Thu, 3 Oct 2024 15:09:45 +0500
Subject: [PATCH 21/43] Support for negative numbers added

---
 .../greedyalgorithms/DigitSeparation.java          |  4 ++--
 .../greedyalgorithms/DigitSeparationTest.java      | 14 ++++++++++++++
 2 files changed, 16 insertions(+), 2 deletions(-)

diff --git a/src/main/java/com/thealgorithms/greedyalgorithms/DigitSeparation.java b/src/main/java/com/thealgorithms/greedyalgorithms/DigitSeparation.java
index 628dadcffa61..bee5f98cd2ee 100644
--- a/src/main/java/com/thealgorithms/greedyalgorithms/DigitSeparation.java
+++ b/src/main/java/com/thealgorithms/greedyalgorithms/DigitSeparation.java
@@ -18,8 +18,8 @@ public DigitSeparation() {
     public List<Long> digitSeparationReverseOrder(long largeNumber) {
         List<Long> result = new ArrayList<>();
         if (largeNumber != 0) {
-            while (largeNumber > 0) {
-                result.add(largeNumber % 10);
+            while (largeNumber != 0) {
+                result.add(Math.abs(largeNumber % 10));
                 largeNumber = largeNumber / 10;
             }
         } else {
diff --git a/src/test/java/com/thealgorithms/greedyalgorithms/DigitSeparationTest.java b/src/test/java/com/thealgorithms/greedyalgorithms/DigitSeparationTest.java
index 78ec47091839..7c445a5c0f85 100644
--- a/src/test/java/com/thealgorithms/greedyalgorithms/DigitSeparationTest.java
+++ b/src/test/java/com/thealgorithms/greedyalgorithms/DigitSeparationTest.java
@@ -34,6 +34,13 @@ public void testDigitSeparationReverseOrderZero() {
         assertEquals(List.of(0L), result);
     }
 
+    @Test
+    public void testDigitSeparationReverseOrderNegativeNumbers() {
+        DigitSeparation digitSeparation = new DigitSeparation();
+        List<Long> result = digitSeparation.digitSeparationReverseOrder(-123);
+        assertEquals(List.of(3L, 2L, 1L), result);
+    }
+
     @Test
     public void testDigitSeparationForwardOrderSingleDigit() {
         DigitSeparation digitSeparation = new DigitSeparation();
@@ -61,4 +68,11 @@ public void testDigitSeparationForwardOrderZero() {
         List<Long> result = digitSeparation.digitSeparationForwardOrder(0);
         assertEquals(List.of(0L), result);
     }
+
+    @Test
+    public void testDigitSeparationForwardOrderNegativeNumber() {
+        DigitSeparation digitSeparation = new DigitSeparation();
+        List<Long> result = digitSeparation.digitSeparationForwardOrder(-123);
+        assertEquals(List.of(3L, 2L, 1L), result);
+    }
 }

From 4f6de8abdcd86768581e890cda3c6930c0f063ed Mon Sep 17 00:00:00 2001
From: mjk22071998 <mjk22071998@gmail.com>
Date: Thu, 3 Oct 2024 15:13:20 +0500
Subject: [PATCH 22/43] Tests corrected

---
 .../com/thealgorithms/greedyalgorithms/DigitSeparationTest.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/test/java/com/thealgorithms/greedyalgorithms/DigitSeparationTest.java b/src/test/java/com/thealgorithms/greedyalgorithms/DigitSeparationTest.java
index 7c445a5c0f85..1fe018ecce18 100644
--- a/src/test/java/com/thealgorithms/greedyalgorithms/DigitSeparationTest.java
+++ b/src/test/java/com/thealgorithms/greedyalgorithms/DigitSeparationTest.java
@@ -73,6 +73,6 @@ public void testDigitSeparationForwardOrderZero() {
     public void testDigitSeparationForwardOrderNegativeNumber() {
         DigitSeparation digitSeparation = new DigitSeparation();
         List<Long> result = digitSeparation.digitSeparationForwardOrder(-123);
-        assertEquals(List.of(3L, 2L, 1L), result);
+        assertEquals(List.of(1L, 2L, 3L), result);
     }
 }

From c53d8d86ec04d78e39e87f8d74c42ed82873b3f8 Mon Sep 17 00:00:00 2001
From: mjk22071998 <mjk22071998@gmail.com>
Date: Sun, 6 Oct 2024 08:14:32 +0500
Subject: [PATCH 23/43] feat: Added binary addition algorithm

---
 .../greedyalgorithms/BinaryAddition.java      | 63 ++++++++++++
 .../greedyalgorithms/BinaryAdditionTest.java  | 97 +++++++++++++++++++
 2 files changed, 160 insertions(+)
 create mode 100644 src/main/java/com/thealgorithms/greedyalgorithms/BinaryAddition.java
 create mode 100644 src/test/java/com/thealgorithms/greedyalgorithms/BinaryAdditionTest.java

diff --git a/src/main/java/com/thealgorithms/greedyalgorithms/BinaryAddition.java b/src/main/java/com/thealgorithms/greedyalgorithms/BinaryAddition.java
new file mode 100644
index 000000000000..af69cc47f155
--- /dev/null
+++ b/src/main/java/com/thealgorithms/greedyalgorithms/BinaryAddition.java
@@ -0,0 +1,63 @@
+package com.thealgorithms.greedyalgorithms;
+
+import java.util.Collections;
+
+/**
+ * Solution class to perform binary addition of two binary strings.
+ */
+public class BinaryAddition {
+    /**
+     * Computes the sum of two binary characters and a carry.
+     * @param a First binary character ('0' or '1').
+     * @param b Second binary character ('0' or '1').
+     * @param carry The carry from the previous operation ('0' or '1').
+     * @return The sum as a binary character ('0' or '1').
+     */
+    public char sum(char a, char b, char carry) {
+        int count = 0;
+        if (a == '1') count++;
+        if (b == '1') count++;
+        if (carry == '1') count++;
+        return count % 2 == 0 ? '0' : '1';
+    }
+    /**
+     * Computes the carry for the next higher bit from two binary characters and a carry.
+     * @param a First binary character ('0' or '1').
+     * @param b Second binary character ('0' or '1').
+     * @param carry The carry from the previous operation ('0' or '1').
+     * @return The carry for the next bit ('0' or '1').
+     */
+    public char carry(char a, char b, char carry) {
+        int count = 0;
+        if (a == '1') count++;
+        if (b == '1') count++;
+        if (carry == '1') count++;
+        return count >= 2 ? '1' : '0';
+    }
+    /**
+     * Adds two binary strings and returns their sum as a binary string.
+     * @param a First binary string.
+     * @param b Second binary string.
+     * @return Binary string representing the sum of the two binary inputs.
+     */
+    public String addBinary(String a, String b) {
+        // Padding the shorter string with leading zeros
+        int maxLength = Math.max(a.length(), b.length());
+        a = String.join("", Collections.nCopies(maxLength - a.length(), "0")) + a;
+        b = String.join("", Collections.nCopies(maxLength - b.length(), "0")) + b;
+        StringBuilder result = new StringBuilder();
+        char carry = '0';
+        // Iterating over the binary strings from the least significant to the most significant bit
+        for (int i = maxLength - 1; i >= 0; i--) {
+            char sum = sum(a.charAt(i), b.charAt(i), carry);
+            carry = carry(a.charAt(i), b.charAt(i), carry);
+            result.append(sum);
+        }
+        // If there's a remaining carry, append it
+        if (carry == '1') {
+            result.append('1');
+        }
+        // Reverse the result as we constructed it from the least significant bit
+        return result.reverse().toString();
+    }
+}
diff --git a/src/test/java/com/thealgorithms/greedyalgorithms/BinaryAdditionTest.java b/src/test/java/com/thealgorithms/greedyalgorithms/BinaryAdditionTest.java
new file mode 100644
index 000000000000..93d1e89bfee7
--- /dev/null
+++ b/src/test/java/com/thealgorithms/greedyalgorithms/BinaryAdditionTest.java
@@ -0,0 +1,97 @@
+package com.thealgorithms.greedyalgorithms;
+
+import org.junit.jupiter.api.Test;
+import static org.junit.jupiter.api.Assertions.*;
+
+public class BinaryAdditionTest {
+
+    BinaryAddition binaryAddition = new BinaryAddition();
+
+    @Test
+    public void testEqualLengthNoCarry() {
+        String a = "1010";
+        String b = "1101";
+        String expected = "10111";
+        assertEquals(expected, binaryAddition.addBinary(a, b));
+    }
+
+    @Test
+    public void testEqualLengthWithCarry() {
+        String a = "1111";
+        String b = "1111";
+        String expected = "11110";
+        assertEquals(expected, binaryAddition.addBinary(a, b));
+    }
+
+    @Test
+    public void testDifferentLengths() {
+        String a = "101";
+        String b = "11";
+        String expected = "1000";
+        assertEquals(expected, binaryAddition.addBinary(a, b));
+    }
+
+    @Test
+    public void testAllZeros() {
+        String a = "0";
+        String b = "0";
+        String expected = "0";
+        assertEquals(expected, binaryAddition.addBinary(a, b));
+    }
+
+
+    @Test
+    public void testAllOnes() {
+        String a = "1111";
+        String b = "1111";
+        String expected = "11110";
+        assertEquals(expected, binaryAddition.addBinary(a, b));
+    }
+
+    @Test
+    public void testOneZeroString() {
+        String a = "0";
+        String b = "10101";
+        String expected = "10101";
+        assertEquals(expected, binaryAddition.addBinary(a, b));
+
+        // Test the other way around
+        a = "10101";
+        b = "0";
+        expected = "10101";
+        assertEquals(expected, binaryAddition.addBinary(a, b));
+    }
+
+    @Test
+    public void testLargeBinaryNumbers() {
+        String a = "101010101010101010101010101010";
+        String b = "110110110110110110110110110110";
+        String expected = "1100001100001100001100001100000";
+        assertEquals(expected, binaryAddition.addBinary(a, b));
+    }
+
+    @Test
+    public void testOneMuchLonger() {
+        String a = "1";
+        String b = "11111111";
+        String expected = "100000000";
+        assertEquals(expected, binaryAddition.addBinary(a, b));
+    }
+
+    @Test
+    public void testEmptyStrings() {
+        String a = "";
+        String b = "";
+        String expected = "0"; // Adding two empty strings should return 0
+        assertEquals(expected, binaryAddition.addBinary(a, b));
+    }
+
+    @Test
+    public void testAlternatingBits() {
+        String a = "10101010";
+        String b = "01010101";
+        String expected = "11111111";
+        assertEquals(expected, binaryAddition.addBinary(a, b));
+    }
+}
+

From e9d9d9c06ab3982e37390aa70ac366fba536edba Mon Sep 17 00:00:00 2001
From: mjk22071998 <mjk22071998@gmail.com>
Date: Sun, 6 Oct 2024 08:25:23 +0500
Subject: [PATCH 24/43] "Updated JavaDoc comment to match class name in
 BinaryAddition.java"

---
 .../java/com/thealgorithms/greedyalgorithms/BinaryAddition.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/main/java/com/thealgorithms/greedyalgorithms/BinaryAddition.java b/src/main/java/com/thealgorithms/greedyalgorithms/BinaryAddition.java
index af69cc47f155..cd46dcd21ab9 100644
--- a/src/main/java/com/thealgorithms/greedyalgorithms/BinaryAddition.java
+++ b/src/main/java/com/thealgorithms/greedyalgorithms/BinaryAddition.java
@@ -3,7 +3,7 @@
 import java.util.Collections;
 
 /**
- * Solution class to perform binary addition of two binary strings.
+ * BinaryAddition class to perform binary addition of two binary strings.
  */
 public class BinaryAddition {
     /**

From eeb8daf96e68daee54ec5d450f87f55fc772944c Mon Sep 17 00:00:00 2001
From: mjk22071998 <mjk22071998@users.noreply.github.com>
Date: Sun, 6 Oct 2024 03:25:47 +0000
Subject: [PATCH 25/43] Update directory

---
 DIRECTORY.md | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/DIRECTORY.md b/DIRECTORY.md
index 1bad5d3b98a3..53b479172147 100644
--- a/DIRECTORY.md
+++ b/DIRECTORY.md
@@ -269,6 +269,7 @@
             * [GrahamScan](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/geometry/GrahamScan.java)
           * greedyalgorithms
             * [ActivitySelection](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/greedyalgorithms/ActivitySelection.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)
             * [FractionalKnapsack](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/greedyalgorithms/FractionalKnapsack.java)
@@ -768,6 +769,7 @@
             * [GrahamScanTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/geometry/GrahamScanTest.java)
           * greedyalgorithms
             * [ActivitySelectionTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/greedyalgorithms/ActivitySelectionTest.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)
             * [FractionalKnapsackTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/greedyalgorithms/FractionalKnapsackTest.java)

From 77d0b95042c9bb184adbd73130ca54dd64d95dc7 Mon Sep 17 00:00:00 2001
From: mjk22071998 <mjk22071998@gmail.com>
Date: Sun, 6 Oct 2024 08:31:27 +0500
Subject: [PATCH 26/43] Updated test file

---
 .../thealgorithms/greedyalgorithms/BinaryAdditionTest.java    | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/test/java/com/thealgorithms/greedyalgorithms/BinaryAdditionTest.java b/src/test/java/com/thealgorithms/greedyalgorithms/BinaryAdditionTest.java
index 93d1e89bfee7..43bcdad16ef8 100644
--- a/src/test/java/com/thealgorithms/greedyalgorithms/BinaryAdditionTest.java
+++ b/src/test/java/com/thealgorithms/greedyalgorithms/BinaryAdditionTest.java
@@ -1,7 +1,7 @@
 package com.thealgorithms.greedyalgorithms;
 
+import static org.junit.jupiter.api.Assertions.assertEquals;
 import org.junit.jupiter.api.Test;
-import static org.junit.jupiter.api.Assertions.*;
 
 public class BinaryAdditionTest {
 
@@ -82,7 +82,7 @@ public void testOneMuchLonger() {
     public void testEmptyStrings() {
         String a = "";
         String b = "";
-        String expected = "0"; // Adding two empty strings should return 0
+        String expected = ""; // Adding two empty strings should return 0
         assertEquals(expected, binaryAddition.addBinary(a, b));
     }
 

From 516e464132f5fd862a293584cb5595461057297b Mon Sep 17 00:00:00 2001
From: mjk22071998 <mjk22071998@gmail.com>
Date: Sun, 6 Oct 2024 08:37:22 +0500
Subject: [PATCH 27/43] clang linted

---
 .../greedyalgorithms/BinaryAddition.java      | 24 ++++++++++++++-----
 1 file changed, 18 insertions(+), 6 deletions(-)

diff --git a/src/main/java/com/thealgorithms/greedyalgorithms/BinaryAddition.java b/src/main/java/com/thealgorithms/greedyalgorithms/BinaryAddition.java
index cd46dcd21ab9..074c76b9f33f 100644
--- a/src/main/java/com/thealgorithms/greedyalgorithms/BinaryAddition.java
+++ b/src/main/java/com/thealgorithms/greedyalgorithms/BinaryAddition.java
@@ -15,9 +15,15 @@ public class BinaryAddition {
      */
     public char sum(char a, char b, char carry) {
         int count = 0;
-        if (a == '1') count++;
-        if (b == '1') count++;
-        if (carry == '1') count++;
+        if (a == '1') {
+            count++;
+        }
+        if (b == '1') {
+            count++;
+        }
+        if (carry == '1') {
+            count++;
+        }
         return count % 2 == 0 ? '0' : '1';
     }
     /**
@@ -29,9 +35,15 @@ public char sum(char a, char b, char carry) {
      */
     public char carry(char a, char b, char carry) {
         int count = 0;
-        if (a == '1') count++;
-        if (b == '1') count++;
-        if (carry == '1') count++;
+        if (a == '1') {
+            count++;
+        }
+        if (b == '1') {
+            count++;
+        }
+        if (carry == '1') {
+            count++;
+        }
         return count >= 2 ? '1' : '0';
     }
     /**

From e623c9b99b742b8d4aaafdf982a0d42cf6151283 Mon Sep 17 00:00:00 2001
From: mjk22071998 <mjk22071998@gmail.com>
Date: Sun, 6 Oct 2024 08:39:47 +0500
Subject: [PATCH 28/43] tests clang linted

---
 .../com/thealgorithms/greedyalgorithms/BinaryAdditionTest.java | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/src/test/java/com/thealgorithms/greedyalgorithms/BinaryAdditionTest.java b/src/test/java/com/thealgorithms/greedyalgorithms/BinaryAdditionTest.java
index 43bcdad16ef8..893ca02ed8a3 100644
--- a/src/test/java/com/thealgorithms/greedyalgorithms/BinaryAdditionTest.java
+++ b/src/test/java/com/thealgorithms/greedyalgorithms/BinaryAdditionTest.java
@@ -1,6 +1,7 @@
 package com.thealgorithms.greedyalgorithms;
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
+
 import org.junit.jupiter.api.Test;
 
 public class BinaryAdditionTest {
@@ -39,7 +40,6 @@ public void testAllZeros() {
         assertEquals(expected, binaryAddition.addBinary(a, b));
     }
 
-
     @Test
     public void testAllOnes() {
         String a = "1111";
@@ -94,4 +94,3 @@ public void testAlternatingBits() {
         assertEquals(expected, binaryAddition.addBinary(a, b));
     }
 }
-

From 8cadc676caa5b222e56136ac74c0e94ab4c7ad2a Mon Sep 17 00:00:00 2001
From: mjk22071998 <mjk22071998@users.noreply.github.com>
Date: Mon, 7 Oct 2024 17:32:31 +0000
Subject: [PATCH 29/43] Update directory

---
 DIRECTORY.md | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/DIRECTORY.md b/DIRECTORY.md
index 87922528abda..409e5b0673d8 100644
--- a/DIRECTORY.md
+++ b/DIRECTORY.md
@@ -476,6 +476,7 @@
           * searches
             * [BinarySearch](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/searches/BinarySearch.java)
             * [BinarySearch2dArray](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/searches/BinarySearch2dArray.java)
+            * [BM25InvertedIndex](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/searches/BM25InvertedIndex.java)
             * [BreadthFirstSearch](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/searches/BreadthFirstSearch.java)
             * [DepthFirstSearch](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/searches/DepthFirstSearch.java)
             * [ExponentalSearch](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/searches/ExponentalSearch.java)
@@ -951,6 +952,7 @@
             * [SRTFSchedulingTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/scheduling/SRTFSchedulingTest.java)
           * searches
             * [BinarySearch2dArrayTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/searches/BinarySearch2dArrayTest.java)
+            * [BM25InvertedIndexTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/searches/BM25InvertedIndexTest.java)
             * [BreadthFirstSearchTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/searches/BreadthFirstSearchTest.java)
             * [DepthFirstSearchTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/searches/DepthFirstSearchTest.java)
             * [HowManyTimesRotatedTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/searches/HowManyTimesRotatedTest.java)

From dc0f03175f97ed28098ce89e82dee0b221ebad74 Mon Sep 17 00:00:00 2001
From: mjk22071998 <mjk22071998@users.noreply.github.com>
Date: Sat, 12 Oct 2024 10:19:57 +0000
Subject: [PATCH 30/43] Update directory

---
 DIRECTORY.md | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/DIRECTORY.md b/DIRECTORY.md
index 30fa2cbee199..9a60fbec929e 100644
--- a/DIRECTORY.md
+++ b/DIRECTORY.md
@@ -54,6 +54,7 @@
               * [CompositeLFSR](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/ciphers/a5/CompositeLFSR.java)
               * [LFSR](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/ciphers/a5/LFSR.java)
               * [Utils](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/ciphers/a5/Utils.java)
+            * [ADFGVXCipher](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/ciphers/ADFGVXCipher.java)
             * [AES](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/ciphers/AES.java)
             * [AESEncryption](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/ciphers/AESEncryption.java)
             * [AffineCipher](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/ciphers/AffineCipher.java)
@@ -133,6 +134,7 @@
               * [FordFulkerson](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/datastructures/graphs/FordFulkerson.java)
               * [Graphs](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/datastructures/graphs/Graphs.java)
               * [HamiltonianCycle](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/datastructures/graphs/HamiltonianCycle.java)
+              * [JohnsonsAlgorithm](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/datastructures/graphs/JohnsonsAlgorithm.java)
               * [KahnsAlgorithm](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/datastructures/graphs/KahnsAlgorithm.java)
               * [Kosaraju](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/datastructures/graphs/Kosaraju.java)
               * [Kruskal](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/datastructures/graphs/Kruskal.java)
@@ -340,6 +342,7 @@
             * [EulersFunction](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/maths/EulersFunction.java)
             * [Factorial](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/maths/Factorial.java)
             * [FactorialRecursion](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/maths/FactorialRecursion.java)
+            * [FastExponentiation](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/maths/FastExponentiation.java)
             * [FastInverseSqrt](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/maths/FastInverseSqrt.java)
             * [FFT](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/maths/FFT.java)
             * [FFTBluestein](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/maths/FFTBluestein.java)
@@ -682,6 +685,7 @@
               * [A5CipherTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/ciphers/a5/A5CipherTest.java)
               * [A5KeyStreamGeneratorTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/ciphers/a5/A5KeyStreamGeneratorTest.java)
               * [LFSRTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/ciphers/a5/LFSRTest.java)
+            * [ADFGVXCipherTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/ciphers/ADFGVXCipherTest.java)
             * [AESEncryptionTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/ciphers/AESEncryptionTest.java)
             * [AffineCipherTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/ciphers/AffineCipherTest.java)
             * [AtbashTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/ciphers/AtbashTest.java)
@@ -750,6 +754,7 @@
               * [FloydWarshallTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/datastructures/graphs/FloydWarshallTest.java)
               * [FordFulkersonTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/datastructures/graphs/FordFulkersonTest.java)
               * [HamiltonianCycleTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/datastructures/graphs/HamiltonianCycleTest.java)
+              * [JohnsonsAlgorithmTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/datastructures/graphs/JohnsonsAlgorithmTest.java)
               * [KosarajuTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/datastructures/graphs/KosarajuTest.java)
               * [TarjansAlgorithmTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/datastructures/graphs/TarjansAlgorithmTest.java)
               * [WelshPowellTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/datastructures/graphs/WelshPowellTest.java)
@@ -902,6 +907,7 @@
             * [EulersFunctionTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/maths/EulersFunctionTest.java)
             * [FactorialRecursionTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/maths/FactorialRecursionTest.java)
             * [FactorialTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/maths/FactorialTest.java)
+            * [FastExponentiationTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/maths/FastExponentiationTest.java)
             * [FastInverseSqrtTests](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/maths/FastInverseSqrtTests.java)
             * [FFTTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/maths/FFTTest.java)
             * [FibonacciJavaStreamsTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/maths/FibonacciJavaStreamsTest.java)

From 980e6e0a3ebf46b45d509c0ae05e29102ed7f5f6 Mon Sep 17 00:00:00 2001
From: mjk22071998 <mjk22071998@users.noreply.github.com>
Date: Tue, 22 Oct 2024 18:39:14 +0000
Subject: [PATCH 31/43] Update directory

---
 DIRECTORY.md | 14 ++++++++++++++
 1 file changed, 14 insertions(+)

diff --git a/DIRECTORY.md b/DIRECTORY.md
index 3d5b2bf61d6a..a98b85dc8b2e 100644
--- a/DIRECTORY.md
+++ b/DIRECTORY.md
@@ -64,12 +64,15 @@
             * [AffineCipher](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/ciphers/AffineCipher.java)
             * [AtbashCipher](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/ciphers/AtbashCipher.java)
             * [Autokey](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/ciphers/Autokey.java)
+            * [BaconianCipher](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/ciphers/BaconianCipher.java)
             * [Blowfish](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/ciphers/Blowfish.java)
             * [Caesar](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/ciphers/Caesar.java)
             * [ColumnarTranspositionCipher](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/ciphers/ColumnarTranspositionCipher.java)
             * [DES](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/ciphers/DES.java)
+            * [DiffieHellman](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/ciphers/DiffieHellman.java)
             * [ECC](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/ciphers/ECC.java)
             * [HillCipher](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/ciphers/HillCipher.java)
+            * [MonoAlphabetic](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/ciphers/MonoAlphabetic.java)
             * [PlayfairCipher](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/ciphers/PlayfairCipher.java)
             * [Polybius](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/ciphers/Polybius.java)
             * [ProductCipher](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/ciphers/ProductCipher.java)
@@ -564,6 +567,7 @@
             * [UnionFind](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/searches/UnionFind.java)
             * [UpperBound](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/searches/UpperBound.java)
           * sorts
+            * [AdaptiveMergeSort](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/sorts/AdaptiveMergeSort.java)
             * [BeadSort](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/sorts/BeadSort.java)
             * [BinaryInsertionSort](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/sorts/BinaryInsertionSort.java)
             * [BitonicSort](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/sorts/BitonicSort.java)
@@ -603,6 +607,7 @@
             * [SortUtils](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/sorts/SortUtils.java)
             * [SortUtilsRandomGenerator](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/sorts/SortUtilsRandomGenerator.java)
             * [SpreadSort](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/sorts/SpreadSort.java)
+            * [StalinSort](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/sorts/StalinSort.java)
             * [StoogeSort](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/sorts/StoogeSort.java)
             * [StrandSort](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/sorts/StrandSort.java)
             * [SwapSort](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/sorts/SwapSort.java)
@@ -616,6 +621,7 @@
             * [CelebrityFinder](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/stacks/CelebrityFinder.java)
             * [DecimalToAnyUsingStack](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/stacks/DecimalToAnyUsingStack.java)
             * [DuplicateBrackets](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/stacks/DuplicateBrackets.java)
+            * [GreatestElementConstantTime](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/stacks/GreatestElementConstantTime.java)
             * [InfixToPostfix](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/stacks/InfixToPostfix.java)
             * [InfixToPrefix](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/stacks/InfixToPrefix.java)
             * [LargestRectangle](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/stacks/LargestRectangle.java)
@@ -628,6 +634,7 @@
             * [PostfixToInfix](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/stacks/PostfixToInfix.java)
             * [PrefixEvaluator](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/stacks/PrefixEvaluator.java)
             * [PrefixToInfix](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/stacks/PrefixToInfix.java)
+            * [SmallestElementConstantTime](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/stacks/SmallestElementConstantTime.java)
             * [SortStack](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/stacks/SortStack.java)
             * [StackPostfixNotation](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/stacks/StackPostfixNotation.java)
             * [StackUsingTwoQueues](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/stacks/StackUsingTwoQueues.java)
@@ -726,12 +733,15 @@
             * [AffineCipherTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/ciphers/AffineCipherTest.java)
             * [AtbashTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/ciphers/AtbashTest.java)
             * [AutokeyTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/ciphers/AutokeyTest.java)
+            * [BaconianCipherTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/ciphers/BaconianCipherTest.java)
             * [BlowfishTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/ciphers/BlowfishTest.java)
             * [CaesarTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/ciphers/CaesarTest.java)
             * [ColumnarTranspositionCipherTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/ciphers/ColumnarTranspositionCipherTest.java)
             * [DESTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/ciphers/DESTest.java)
+            * [DiffieHellmanTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/ciphers/DiffieHellmanTest.java)
             * [ECCTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/ciphers/ECCTest.java)
             * [HillCipherTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/ciphers/HillCipherTest.java)
+            * [MonoAlphabeticTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/ciphers/MonoAlphabeticTest.java)
             * [PlayfairTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/ciphers/PlayfairTest.java)
             * [PolybiusTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/ciphers/PolybiusTest.java)
             * [RailFenceTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/ciphers/RailFenceTest.java)
@@ -1133,6 +1143,7 @@
             * [UnionFindTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/searches/UnionFindTest.java)
             * [UpperBoundTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/searches/UpperBoundTest.java)
           * sorts
+            * [AdaptiveMergeSortTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/sorts/AdaptiveMergeSortTest.java)
             * [BeadSortTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/sorts/BeadSortTest.java)
             * [BinaryInsertionSortTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/sorts/BinaryInsertionSortTest.java)
             * [BitonicSortTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/sorts/BitonicSortTest.java)
@@ -1171,6 +1182,7 @@
             * [SortUtilsRandomGeneratorTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/sorts/SortUtilsRandomGeneratorTest.java)
             * [SortUtilsTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/sorts/SortUtilsTest.java)
             * [SpreadSortTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/sorts/SpreadSortTest.java)
+            * [StalinSortTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/sorts/StalinSortTest.java)
             * [StoogeSortTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/sorts/StoogeSortTest.java)
             * [StrandSortTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/sorts/StrandSortTest.java)
             * [SwapSortTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/sorts/SwapSortTest.java)
@@ -1184,6 +1196,7 @@
             * [CelebrityFinderTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/stacks/CelebrityFinderTest.java)
             * [DecimalToAnyUsingStackTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/stacks/DecimalToAnyUsingStackTest.java)
             * [DuplicateBracketsTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/stacks/DuplicateBracketsTest.java)
+            * [GreatestElementConstantTimeTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/stacks/GreatestElementConstantTimeTest.java)
             * [InfixToPostfixTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/stacks/InfixToPostfixTest.java)
             * [InfixToPrefixTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/stacks/InfixToPrefixTest.java)
             * [LargestRectangleTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/stacks/LargestRectangleTest.java)
@@ -1195,6 +1208,7 @@
             * [PostfixToInfixTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/stacks/PostfixToInfixTest.java)
             * [PrefixEvaluatorTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/stacks/PrefixEvaluatorTest.java)
             * [PrefixToInfixTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/stacks/PrefixToInfixTest.java)
+            * [SmallestElementConstantTimeTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/stacks/SmallestElementConstantTimeTest.java)
             * [SortStackTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/stacks/SortStackTest.java)
             * [StackPostfixNotationTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/stacks/StackPostfixNotationTest.java)
             * [StackUsingTwoQueuesTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/stacks/StackUsingTwoQueuesTest.java)

From 0b632120ae52c9190e124adb07c11c40f46de068 Mon Sep 17 00:00:00 2001
From: mjk22071998 <mjk22071998@gmail.com>
Date: Mon, 28 Oct 2024 16:43:18 +0500
Subject: [PATCH 32/43] Added Uniform Numbers Algorithms

---
 .../thealgorithms/maths/UniformNumbers.java   | 23 +++++++
 .../maths/UniformNumbersTest.java             | 62 +++++++++++++++++++
 2 files changed, 85 insertions(+)
 create mode 100644 src/main/java/com/thealgorithms/maths/UniformNumbers.java
 create mode 100644 src/test/java/com/thealgorithms/maths/UniformNumbersTest.java

diff --git a/src/main/java/com/thealgorithms/maths/UniformNumbers.java b/src/main/java/com/thealgorithms/maths/UniformNumbers.java
new file mode 100644
index 000000000000..8f4a7e48fdd4
--- /dev/null
+++ b/src/main/java/com/thealgorithms/maths/UniformNumbers.java
@@ -0,0 +1,23 @@
+package com.thealgorithms.maths;
+
+public class UniformNumbers {
+
+    public static int uniformNumbers(int num) {
+        String numStr = Integer.toString(num);
+        int uniformCount = (numStr.length() - 1) * 9; // Count for digits less than current length
+        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;
+    }
+
+    public static int countUniformIntegers(int A, int B) {
+        return uniformNumbers(B) - uniformNumbers(A - 1);
+    }
+}
+
diff --git a/src/test/java/com/thealgorithms/maths/UniformNumbersTest.java b/src/test/java/com/thealgorithms/maths/UniformNumbersTest.java
new file mode 100644
index 000000000000..cfc2da7c9e41
--- /dev/null
+++ b/src/test/java/com/thealgorithms/maths/UniformNumbersTest.java
@@ -0,0 +1,62 @@
+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)); // Only one number, which is uniform
+        assertEquals(9, UniformNumbers.countUniformIntegers(1, 9)); // All single-digit numbers are uniform
+    }
+
+    @Test
+    void testSmallRange() {
+        assertEquals(2, UniformNumbers.countUniformIntegers(10, 11)); // Only uniform number is 11
+        assertEquals(4, UniformNumbers.countUniformIntegers(22, 33)); // Uniform numbers are 22, 33
+    }
+
+    @Test
+    void testRangeWithNoUniformNumbers() {
+        assertEquals(0, UniformNumbers.countUniformIntegers(10, 21)); // No uniform numbers between 10 and 21
+        assertEquals(0, UniformNumbers.countUniformIntegers(123, 128)); // No uniform numbers between 123 and 128
+    }
+
+    @Test
+    void testRangeWithAllUniformNumbers() {
+        assertEquals(9, UniformNumbers.countUniformIntegers(1, 9)); // All are uniform numbers
+        assertEquals(18, UniformNumbers.countUniformIntegers(1, 99)); // 1-9 and 11, 22, ..., 99
+    }
+
+    @Test
+    void testMultiDigitRangeWithUniformNumbers() {
+        assertEquals(2, UniformNumbers.countUniformIntegers(100, 111)); // Only 111 is uniform
+        assertEquals(4, UniformNumbers.countUniformIntegers(111, 222)); // Uniform numbers are 111, 222
+    }
+
+    @Test
+    void testExactUniformBoundary() {
+        assertEquals(1, UniformNumbers.countUniformIntegers(111, 111)); // Only one number, which is uniform
+        assertEquals(2, UniformNumbers.countUniformIntegers(111, 222)); // Uniform numbers are 111, 222
+    }
+
+    @Test
+    void testLargeRange() {
+        assertEquals(36, UniformNumbers.countUniformIntegers(1, 999)); // Counts all 1-digit, 2-digit, and 3-digit uniform numbers
+        assertEquals(45, UniformNumbers.countUniformIntegers(1, 9999)); // Adds 4-digit uniform numbers too
+    }
+
+    @Test
+    void testUpperBoundary() {
+        assertEquals(9, UniformNumbers.countUniformIntegers(1, Integer.MAX_VALUE)); // Test with maximum possible integer range
+    }
+
+    @Test
+    void testInvalidRange() {
+        assertEquals(0, UniformNumbers.countUniformIntegers(500, 100)); // Invalid range (A > B)
+        assertEquals(0, UniformNumbers.countUniformIntegers(-100, -1)); // Negative numbers, not in range of positive integers
+    }
+
+}

From 84ed59142c70e191f2d8c2d284f2f5ae50a0be28 Mon Sep 17 00:00:00 2001
From: mjk22071998 <mjk22071998@users.noreply.github.com>
Date: Mon, 28 Oct 2024 11:46:00 +0000
Subject: [PATCH 33/43] Update directory

---
 DIRECTORY.md | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/DIRECTORY.md b/DIRECTORY.md
index a98b85dc8b2e..d98430144571 100644
--- a/DIRECTORY.md
+++ b/DIRECTORY.md
@@ -444,6 +444,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)
@@ -1042,6 +1043,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)

From ac359ecadc4d9b73001f260e6fcb288b3cef6831 Mon Sep 17 00:00:00 2001
From: mjk22071998 <mjk22071998@users.noreply.github.com>
Date: Mon, 28 Oct 2024 11:48:03 +0000
Subject: [PATCH 34/43] Update directory

---
 DIRECTORY.md | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/DIRECTORY.md b/DIRECTORY.md
index 76c220f73923..e34b9eba1247 100644
--- a/DIRECTORY.md
+++ b/DIRECTORY.md
@@ -598,6 +598,7 @@
             * [UnionFind](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/searches/UnionFind.java)
             * [UpperBound](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/searches/UpperBound.java)
           * slidingwindow
+            * [LongestSubarrayWithSumLessOrEqualToK](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/slidingwindow/LongestSubarrayWithSumLessOrEqualToK.java)
             * [LongestSubstringWithoutRepeatingCharacters](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/slidingwindow/LongestSubstringWithoutRepeatingCharacters.java)
             * [MaxSumKSizeSubarray](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/slidingwindow/MaxSumKSizeSubarray.java)
             * [MinSumKSizeSubarray](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/slidingwindow/MinSumKSizeSubarray.java)
@@ -1230,6 +1231,7 @@
             * [UnionFindTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/searches/UnionFindTest.java)
             * [UpperBoundTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/searches/UpperBoundTest.java)
           * slidingwindow
+            * [LongestSubarrayWithSumLessOrEqualToKTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/slidingwindow/LongestSubarrayWithSumLessOrEqualToKTest.java)
             * [LongestSubstringWithoutRepeatingCharactersTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/slidingwindow/LongestSubstringWithoutRepeatingCharactersTest.java)
             * [MaxSumKSizeSubarrayTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/slidingwindow/MaxSumKSizeSubarrayTest.java)
             * [MinSumKSizeSubarrayTest](https://github.com/TheAlgorithms/Java/blob/master/src/test/java/com/thealgorithms/slidingwindow/MinSumKSizeSubarrayTest.java)

From edf1abbedcaca0739b38d93d59fd21b0a4c53821 Mon Sep 17 00:00:00 2001
From: mjk22071998 <mjk22071998@gmail.com>
Date: Mon, 28 Oct 2024 16:54:36 +0500
Subject: [PATCH 35/43] clang formatted

---
 src/main/java/com/thealgorithms/maths/UniformNumbers.java  | 7 +++++--
 .../java/com/thealgorithms/maths/UniformNumbersTest.java   | 1 -
 2 files changed, 5 insertions(+), 3 deletions(-)

diff --git a/src/main/java/com/thealgorithms/maths/UniformNumbers.java b/src/main/java/com/thealgorithms/maths/UniformNumbers.java
index 8f4a7e48fdd4..820dd5be183d 100644
--- a/src/main/java/com/thealgorithms/maths/UniformNumbers.java
+++ b/src/main/java/com/thealgorithms/maths/UniformNumbers.java
@@ -17,7 +17,10 @@ public static int uniformNumbers(int num) {
     }
 
     public static int countUniformIntegers(int A, int B) {
-        return uniformNumbers(B) - uniformNumbers(A - 1);
+        if (B > A) {
+            return uniformNumbers(B) - uniformNumbers(A - 1);
+        } else {
+            return 0;
+        }
     }
 }
-
diff --git a/src/test/java/com/thealgorithms/maths/UniformNumbersTest.java b/src/test/java/com/thealgorithms/maths/UniformNumbersTest.java
index cfc2da7c9e41..cba3f1c8266e 100644
--- a/src/test/java/com/thealgorithms/maths/UniformNumbersTest.java
+++ b/src/test/java/com/thealgorithms/maths/UniformNumbersTest.java
@@ -58,5 +58,4 @@ void testInvalidRange() {
         assertEquals(0, UniformNumbers.countUniformIntegers(500, 100)); // Invalid range (A > B)
         assertEquals(0, UniformNumbers.countUniformIntegers(-100, -1)); // Negative numbers, not in range of positive integers
     }
-
 }

From a7262fb4c6d6b3cfadf6b17076eda2af8c7a9457 Mon Sep 17 00:00:00 2001
From: mjk22071998 <mjk22071998@gmail.com>
Date: Mon, 28 Oct 2024 16:59:03 +0500
Subject: [PATCH 36/43] tests corrected

---
 .../maths/UniformNumbersTest.java             | 29 ++++++++-----------
 1 file changed, 12 insertions(+), 17 deletions(-)

diff --git a/src/test/java/com/thealgorithms/maths/UniformNumbersTest.java b/src/test/java/com/thealgorithms/maths/UniformNumbersTest.java
index cba3f1c8266e..d704badad679 100644
--- a/src/test/java/com/thealgorithms/maths/UniformNumbersTest.java
+++ b/src/test/java/com/thealgorithms/maths/UniformNumbersTest.java
@@ -14,8 +14,8 @@ void testSingleUniformDigitRange() {
 
     @Test
     void testSmallRange() {
-        assertEquals(2, UniformNumbers.countUniformIntegers(10, 11)); // Only uniform number is 11
-        assertEquals(4, UniformNumbers.countUniformIntegers(22, 33)); // Uniform numbers are 22, 33
+        assertEquals(1, UniformNumbers.countUniformIntegers(10, 11)); // Only uniform number is 11
+        assertEquals(2, UniformNumbers.countUniformIntegers(22, 33)); // Uniform numbers are 22, 33
     }
 
     @Test
@@ -26,36 +26,31 @@ void testRangeWithNoUniformNumbers() {
 
     @Test
     void testRangeWithAllUniformNumbers() {
-        assertEquals(9, UniformNumbers.countUniformIntegers(1, 9)); // All are uniform numbers
-        assertEquals(18, UniformNumbers.countUniformIntegers(1, 99)); // 1-9 and 11, 22, ..., 99
+        assertEquals(9, UniformNumbers.countUniformIntegers(1, 9)); 
+        assertEquals(18, UniformNumbers.countUniformIntegers(1, 99)); 
     }
 
     @Test
     void testMultiDigitRangeWithUniformNumbers() {
-        assertEquals(2, UniformNumbers.countUniformIntegers(100, 111)); // Only 111 is uniform
-        assertEquals(4, UniformNumbers.countUniformIntegers(111, 222)); // Uniform numbers are 111, 222
+        assertEquals(1, UniformNumbers.countUniformIntegers(100, 111)); 
+        assertEquals(2, UniformNumbers.countUniformIntegers(111, 222)); 
     }
 
     @Test
     void testExactUniformBoundary() {
-        assertEquals(1, UniformNumbers.countUniformIntegers(111, 111)); // Only one number, which is uniform
-        assertEquals(2, UniformNumbers.countUniformIntegers(111, 222)); // Uniform numbers are 111, 222
+        assertEquals(1, UniformNumbers.countUniformIntegers(111, 111));
+        assertEquals(2, UniformNumbers.countUniformIntegers(111, 222));
     }
 
     @Test
     void testLargeRange() {
-        assertEquals(36, UniformNumbers.countUniformIntegers(1, 999)); // Counts all 1-digit, 2-digit, and 3-digit uniform numbers
-        assertEquals(45, UniformNumbers.countUniformIntegers(1, 9999)); // Adds 4-digit uniform numbers too
-    }
-
-    @Test
-    void testUpperBoundary() {
-        assertEquals(9, UniformNumbers.countUniformIntegers(1, Integer.MAX_VALUE)); // Test with maximum possible integer range
+        assertEquals(27, UniformNumbers.countUniformIntegers(1, 999)); 
+        assertEquals(36, UniformNumbers.countUniformIntegers(1, 9999));
     }
 
     @Test
     void testInvalidRange() {
-        assertEquals(0, UniformNumbers.countUniformIntegers(500, 100)); // Invalid range (A > B)
-        assertEquals(0, UniformNumbers.countUniformIntegers(-100, -1)); // Negative numbers, not in range of positive integers
+        assertEquals(0, UniformNumbers.countUniformIntegers(500, 100));
+        assertEquals(0, UniformNumbers.countUniformIntegers(-100, -1));
     }
 }

From 91308b4d81484e9bf7c6e9cca5913348c6cd86b8 Mon Sep 17 00:00:00 2001
From: mjk22071998 <mjk22071998@gmail.com>
Date: Mon, 28 Oct 2024 17:11:57 +0500
Subject: [PATCH 37/43] build erros corrected

---
 src/main/java/com/thealgorithms/maths/UniformNumbers.java     | 2 ++
 src/test/java/com/thealgorithms/maths/UniformNumbersTest.java | 2 +-
 2 files changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/main/java/com/thealgorithms/maths/UniformNumbers.java b/src/main/java/com/thealgorithms/maths/UniformNumbers.java
index 820dd5be183d..a6e4a1cb0f22 100644
--- a/src/main/java/com/thealgorithms/maths/UniformNumbers.java
+++ b/src/main/java/com/thealgorithms/maths/UniformNumbers.java
@@ -19,6 +19,8 @@ public static int uniformNumbers(int num) {
     public static int countUniformIntegers(int A, int B) {
         if (B > A) {
             return uniformNumbers(B) - uniformNumbers(A - 1);
+        } else if (B == A) {
+            return 1;
         } else {
             return 0;
         }
diff --git a/src/test/java/com/thealgorithms/maths/UniformNumbersTest.java b/src/test/java/com/thealgorithms/maths/UniformNumbersTest.java
index d704badad679..e72a0d3a5157 100644
--- a/src/test/java/com/thealgorithms/maths/UniformNumbersTest.java
+++ b/src/test/java/com/thealgorithms/maths/UniformNumbersTest.java
@@ -20,7 +20,7 @@ void testSmallRange() {
 
     @Test
     void testRangeWithNoUniformNumbers() {
-        assertEquals(0, UniformNumbers.countUniformIntegers(10, 21)); // No uniform numbers between 10 and 21
+        assertEquals(0, UniformNumbers.countUniformIntegers(12, 21)); // No uniform numbers between 10 and 21
         assertEquals(0, UniformNumbers.countUniformIntegers(123, 128)); // No uniform numbers between 123 and 128
     }
 

From 8b9ba95a2def7602ed3cec19bc553829d5b7f521 Mon Sep 17 00:00:00 2001
From: mjk22071998 <mjk22071998@gmail.com>
Date: Mon, 28 Oct 2024 17:15:01 +0500
Subject: [PATCH 38/43] removed trailing whitespaces

---
 .../maths/UniformNumbersTest.java             | 22 +++++++++----------
 1 file changed, 11 insertions(+), 11 deletions(-)

diff --git a/src/test/java/com/thealgorithms/maths/UniformNumbersTest.java b/src/test/java/com/thealgorithms/maths/UniformNumbersTest.java
index e72a0d3a5157..ac46c00014ad 100644
--- a/src/test/java/com/thealgorithms/maths/UniformNumbersTest.java
+++ b/src/test/java/com/thealgorithms/maths/UniformNumbersTest.java
@@ -8,32 +8,32 @@ class UniformNumbersTest {
 
     @Test
     void testSingleUniformDigitRange() {
-        assertEquals(1, UniformNumbers.countUniformIntegers(1, 1)); // Only one number, which is uniform
-        assertEquals(9, UniformNumbers.countUniformIntegers(1, 9)); // All single-digit numbers are uniform
+        assertEquals(1, UniformNumbers.countUniformIntegers(1, 1));
+        assertEquals(9, UniformNumbers.countUniformIntegers(1, 9));
     }
 
     @Test
     void testSmallRange() {
-        assertEquals(1, UniformNumbers.countUniformIntegers(10, 11)); // Only uniform number is 11
-        assertEquals(2, UniformNumbers.countUniformIntegers(22, 33)); // Uniform numbers are 22, 33
+        assertEquals(1, UniformNumbers.countUniformIntegers(10, 11));
+        assertEquals(2, UniformNumbers.countUniformIntegers(22, 33));
     }
 
     @Test
     void testRangeWithNoUniformNumbers() {
-        assertEquals(0, UniformNumbers.countUniformIntegers(12, 21)); // No uniform numbers between 10 and 21
-        assertEquals(0, UniformNumbers.countUniformIntegers(123, 128)); // No uniform numbers between 123 and 128
+        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)); 
+        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)); 
+        assertEquals(1, UniformNumbers.countUniformIntegers(100, 111));
+        assertEquals(2, UniformNumbers.countUniformIntegers(111, 222));
     }
 
     @Test
@@ -44,7 +44,7 @@ void testExactUniformBoundary() {
 
     @Test
     void testLargeRange() {
-        assertEquals(27, UniformNumbers.countUniformIntegers(1, 999)); 
+        assertEquals(27, UniformNumbers.countUniformIntegers(1, 999));
         assertEquals(36, UniformNumbers.countUniformIntegers(1, 9999));
     }
 

From a486ac00fd57adbd50721af0eb426b7bb232a873 Mon Sep 17 00:00:00 2001
From: mjk22071998 <mjk22071998@gmail.com>
Date: Mon, 28 Oct 2024 17:17:49 +0500
Subject: [PATCH 39/43] Omitted negative numbers

---
 src/main/java/com/thealgorithms/maths/UniformNumbers.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/main/java/com/thealgorithms/maths/UniformNumbers.java b/src/main/java/com/thealgorithms/maths/UniformNumbers.java
index a6e4a1cb0f22..21ff66eb1022 100644
--- a/src/main/java/com/thealgorithms/maths/UniformNumbers.java
+++ b/src/main/java/com/thealgorithms/maths/UniformNumbers.java
@@ -17,7 +17,7 @@ public static int uniformNumbers(int num) {
     }
 
     public static int countUniformIntegers(int A, int B) {
-        if (B > A) {
+        if (B > A && (B > 0 && A > 0)) {
             return uniformNumbers(B) - uniformNumbers(A - 1);
         } else if (B == A) {
             return 1;

From 2b4b54c6553dc1c64843f7c86c54efc882c0b783 Mon Sep 17 00:00:00 2001
From: mjk22071998 <mjk22071998@gmail.com>
Date: Mon, 28 Oct 2024 17:23:36 +0500
Subject: [PATCH 40/43] Styles corrected and added private constructor

---
 .../com/thealgorithms/maths/UniformNumbers.java     | 13 +++++++++----
 1 file changed, 9 insertions(+), 4 deletions(-)

diff --git a/src/main/java/com/thealgorithms/maths/UniformNumbers.java b/src/main/java/com/thealgorithms/maths/UniformNumbers.java
index 21ff66eb1022..63bfbeee0a33 100644
--- a/src/main/java/com/thealgorithms/maths/UniformNumbers.java
+++ b/src/main/java/com/thealgorithms/maths/UniformNumbers.java
@@ -2,6 +2,11 @@
 
 public class UniformNumbers {
 
+    // Private constructor to prevent instantiation of the utility class
+    private UniformNumbers() {
+        // Prevent instantiation
+    }
+
     public static int uniformNumbers(int num) {
         String numStr = Integer.toString(num);
         int uniformCount = (numStr.length() - 1) * 9; // Count for digits less than current length
@@ -16,10 +21,10 @@ public static int uniformNumbers(int num) {
         return uniformCount;
     }
 
-    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) {
+    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;

From e3110033f502dcfe9049cec838aff01785c9709d Mon Sep 17 00:00:00 2001
From: mjk22071998 <mjk22071998@gmail.com>
Date: Mon, 28 Oct 2024 17:30:38 +0500
Subject: [PATCH 41/43] made class final

---
 src/main/java/com/thealgorithms/maths/UniformNumbers.java | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/main/java/com/thealgorithms/maths/UniformNumbers.java b/src/main/java/com/thealgorithms/maths/UniformNumbers.java
index 63bfbeee0a33..836651612aac 100644
--- a/src/main/java/com/thealgorithms/maths/UniformNumbers.java
+++ b/src/main/java/com/thealgorithms/maths/UniformNumbers.java
@@ -1,6 +1,6 @@
 package com.thealgorithms.maths;
 
-public class UniformNumbers {
+public final class UniformNumbers {
 
     // Private constructor to prevent instantiation of the utility class
     private UniformNumbers() {
@@ -9,7 +9,7 @@ private UniformNumbers() {
 
     public static int uniformNumbers(int num) {
         String numStr = Integer.toString(num);
-        int uniformCount = (numStr.length() - 1) * 9; // Count for digits less than current length
+        int uniformCount = (numStr.length() - 1) * 9;
         int finalUniform = Integer.parseInt(String.valueOf(numStr.charAt(0)).repeat(numStr.length()));
 
         if (finalUniform <= num) {

From fc44a87ef01be0423ebdb0c60b51d0513074bb8e Mon Sep 17 00:00:00 2001
From: mjk22071998 <mjk22071998@gmail.com>
Date: Mon, 28 Oct 2024 17:47:46 +0500
Subject: [PATCH 42/43] removed unnecessary paranthesis

---
 src/main/java/com/thealgorithms/maths/UniformNumbers.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/main/java/com/thealgorithms/maths/UniformNumbers.java b/src/main/java/com/thealgorithms/maths/UniformNumbers.java
index 836651612aac..0052db740596 100644
--- a/src/main/java/com/thealgorithms/maths/UniformNumbers.java
+++ b/src/main/java/com/thealgorithms/maths/UniformNumbers.java
@@ -22,7 +22,7 @@ public static int uniformNumbers(int num) {
     }
 
     public static int countUniformIntegers(int a, int b) {
-        if (b > a && (b > 0 && a > 0)) {
+        if (b > a && b > 0 && a > 0) {
             return uniformNumbers(b) - uniformNumbers(a - 1);
         } else if (b == a) {
             return 1;

From 95e927c8dace26d21d886c2e61e8fd4af0479fe0 Mon Sep 17 00:00:00 2001
From: mjk22071998 <mjk22071998@gmail.com>
Date: Mon, 28 Oct 2024 18:36:22 +0500
Subject: [PATCH 43/43] documentation added

---
 .../thealgorithms/maths/UniformNumbers.java   | 23 ++++++++++++++++---
 1 file changed, 20 insertions(+), 3 deletions(-)

diff --git a/src/main/java/com/thealgorithms/maths/UniformNumbers.java b/src/main/java/com/thealgorithms/maths/UniformNumbers.java
index 0052db740596..c83783aab0b3 100644
--- a/src/main/java/com/thealgorithms/maths/UniformNumbers.java
+++ b/src/main/java/com/thealgorithms/maths/UniformNumbers.java
@@ -1,12 +1,23 @@
 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;
@@ -20,7 +31,13 @@ public static int uniformNumbers(int num) {
 
         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);