Minor changes

Author: czgdp1807

pydatastructs/linear_data_structures/algorithms.py

@@ -789,36 +789,52 @@ def longest_common_subsequence(seq1: OneDimensionalArray, seq2: OneDimensionalAr
 
     return OneDimensionalArray(seq1._dtype, check_mat[row][col][-1])
 
-def is_ordered(array, start, end, comp):
+def is_ordered(array, **kwargs):
     """
     Checks whether the given array is ordered or not.
 
     Parameters
-    =========
-    array : OneDimensionalArray
-        The array which is to be checked for sort.
-
-    start : int
-        The starting index of the portion of array to be checked.
+    ==========
 
-    end : int
-        The ending index of the portion of array to be checked.
+    array: Array
+        The array which is to be checked for having
+        specified ordered among its elements.
+    start: int
+        The starting index of the portion
+        which is to be sorted.
+        Optional, by default 0
+    end: int
+        The ending index of the portion which
+        is to be sorted.
+        Optional, by default the index
+        of the last position filled.
+    comp: lambda/function
+        The comparator which is to be used
+        for sorting. If the function returns
+        False then only swapping is performed.
+        Optional, by default, less than or
+        equal to is used for comparing two
+        values.
 
     Examples
     ========
 
     >>> from pydatastructs import OneDimensionalArray, is_ordered
-    >>> arr = OneDimensionalArray(int, [4, 3, 2, 1])
-    >>> is_ordered(arr, 0, 3, None)
-    False
-    >>> arr1 = OneDimensionalArray(int, [1, 2, 3])
-    >>> is_ordered(arr1, 0, 2, None)
+    >>> arr = OneDimensionalArray(int, [1, 2, 3, 4])
+    >>> is_ordered(arr)
     True
+    >>> arr1 = OneDimensionalArray(int, [1, 2, 3])
+    >>> is_ordered(arr1, start=0, end=1, comp=lambda u, v: u > v)
+    False
 
     """
-    if comp is None:
-        comp = lambda a, b: a < b
-    for i in range(start + 1, end + 1):
-        if(comp(array[i], array[i - 1])):
+    lower = kwargs.get('start', 0)
+    upper = kwargs.get('end', len(array) - 1)
+    comp = kwargs.get("comp", lambda u, v: u <= v)
+
+    for i in range(lower + 1, upper + 1):
+        if array[i] is None or array[i - 1] is None:
+            continue
+        if comp(array[i], array[i - 1]):
             return False
     return True

pydatastructs/linear_data_structures/tests/test_algorithms.py

@@ -1,7 +1,8 @@
 from pydatastructs import (
     merge_sort_parallel, DynamicOneDimensionalArray,
     OneDimensionalArray, brick_sort, brick_sort_parallel,
-    heapsort, matrix_multiply_parallel, counting_sort, bucket_sort, cocktail_shaker_sort, quick_sort, longest_common_subsequence, is_ordered)
+    heapsort, matrix_multiply_parallel, counting_sort, bucket_sort,
+    cocktail_shaker_sort, quick_sort, longest_common_subsequence, is_ordered)
 
 
 from pydatastructs.utils.raises_util import raises
@@ -129,33 +130,30 @@ def test_longest_common_sequence():
 
 def test_is_ordered():
     ODA = OneDimensionalArray
+    DODA = DynamicOneDimensionalArray
 
     expected_result = True
-
     arr = ODA(int, [1, 2, 5, 6])
-    output = is_ordered(arr, 0, len(arr)-1, None)
+    output = is_ordered(arr)
     assert output == expected_result
 
     expected_result = False
-
     arr1 = ODA(int, [4, 3, 2, 1])
-    output = is_ordered(arr1, 0, len(arr1)-1, None)
+    output = is_ordered(arr1)
     assert output == expected_result
 
     expected_result = True
-
     arr2 = ODA(int, [6, 1, 2, 3, 4, 5])
-    output = is_ordered(arr2, 1, 5, None)
+    output = is_ordered(arr2, start=1, end=5)
     assert output == expected_result
 
-    expected_result = False
-
+    expected_result = True
     arr3 = ODA(int, [0, -1, -2, -3, -4, 4])
-    output = is_ordered(arr3, 0, 5, None)
+    output = is_ordered(arr3, start=1, end=4, comp=lambda u, v: u > v)
     assert output == expected_result
 
     expected_result = True
-
-    arr4 = ODA(int, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
-    output = is_ordered(arr4, 0, 9, None)
+    arr4 = DODA(int, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
+    arr4.delete(0)
+    output = is_ordered(arr4)
     assert output == expected_result