# Python Program to extracts elements from the list with digits in increasing order

Given a List of elements, extract all elements which have digits that are increasing in order.

```Input : test_list = [1234, 7373, 3643, 3527, 148, 49]
Output : [1234, 148, 49]
Explanation : All elements have increasing digits.```
```Input : test_list = [12341, 7373, 3643, 3527, 1481, 491]
Output : []
Explanation : No elements have all increasing digits. ```

Method 1: Using loop and str()

In this, we convert each element to a string and then check if each digit is greater than the previous one using a loop.

## Python3

 `# initializing list` `test_list ``=` `[``1234``, ``7373``, ``3643``, ``3527``, ``148``]`   `# printing original list` `print``(``"The original list is : "` `+` `str``(test_list))`   `# loop to check for each element` `res ``=` `[]` `for` `ele ``in` `test_list:` `    ``flag ``=` `True` `    `  `    ``for` `idx ``in` `range``(``len``(``str``(ele)) ``-` `1``):` `        `  `        ``# checking for each next digit` `        ``if` `str``(ele)[idx ``+` `1``] <``=` `str``(ele)[idx]:` `            ``flag ``=` `False` `    `  `    ``if` `flag:` `        ``res.append(ele)` `        `  `# printing result ` `print``(``"Extracted increasing digits : "` `+` `str``(res))`

Output:

```The original list is : [1234, 7373, 3643, 3527, 148]
Extracted increasing digits : [1234, 148]```

Time complexity: O(n*m) where n is the length of the list and m is the maximum number of digits in a number in the list.
Auxiliary space: O(k) where k is the number of increasing digit numbers in the list.

Method 2 : Using sorted(), list comprehension and str()

In this, we test for each digit of an element to be increasing by sorting each element and comparing it with original version. If they are same, the element is added to desired list.

## Python3

 `# initializing list` `test_list ``=` `[``1234``, ``7373``, ``3643``, ``3527``, ``148``]`   `# printing original list` `print``(``"The original list is : "` `+` `str``(test_list))`   `# sorting and comparing for equality` `res ``=` `[ele ``for` `ele ``in` `test_list ``if` `''.join(``sorted``(``str``(ele))) ``=``=` `str``(ele)]` `        `  `# printing result ` `print``(``"Extracted increasing digits : "` `+` `str``(res))`

Output:

```The original list is : [1234, 7373, 3643, 3527, 148]
Extracted increasing digits : [1234, 148]```

Time complexity: O(nlogn), where n is the length of the list.
Auxiliary space: O(n), where n is the length of the list.

Method 3 :  Using map() function and lambda

1. Initialize the input list
2. Define a lambda function to extract the increasing digits in each element of the list.
3. Use the map() function along with the lambda function to extract the increasing digits in each element of the list.
4. Print the result.

## Python3

 `# initialize input list` `test_list ``=` `[``1234``, ``7373``, ``3643``, ``3527``, ``148``]`   `# define lambda function to extract increasing digits in each element` `extract_inc_digits ``=` `lambda` `x: ``all``(``str``(x)[i] < ``str``(x)[i``+``1``] ``for` `i ``in` `range``(``len``(``str``(x))``-``1``))`   `# use map() and filter() to extract increasing digits in each element` `res ``=` `list``(``filter``(extract_inc_digits, test_list))`   `# print result` `print``(``"Extracted increasing digits : "` `+` `str``(res))`

Output

`Extracted increasing digits : [1234, 148]`

Time complexity: O(nk), where n is the length of the input list and k is the maximum number of digits in an element of the list.
Auxiliary space: O(k), since we are only storing the digits of each element in memory during the execution of the lambda function.

Method 4: Using the built-in filter() function

Steps:

1. We define a function is_increasing() which takes a number as input and returns True if the digits of the number are in increasing order, and False otherwise.
2. We use the filter() function to apply this function to each element of the test_list and return only the elements for which the function returns True.
3. We convert the resulting filter object to a list using list() function.
4. We print the final result.

## Python3

 `# initializing list` `test_list ``=` `[``1234``, ``7373``, ``3643``, ``3527``, ``148``]`   `# printing original list` `print``(``"The original list is : "` `+` `str``(test_list))`   `# function to check if digits are in increasing order`     `def` `is_increasing(num):` `    ``digits ``=` `list``(``str``(num))` `    ``return` `all``(``int``(digits[i]) < ``int``(digits[i``+``1``])`   `               ``for` `i ``in` `range``(``len``(digits)``-``1``))`     `# Extracting elements with increasing digits` `# using filter() method` `res ``=` `list``(``filter``(is_increasing, test_list))`   `# printing result` `print``(``"Extracted increasing digits : "` `+` `str``(res))`

Output

```The original list is : [1234, 7373, 3643, 3527, 148]
Extracted increasing digits : [1234, 148]```

Time complexity: O(n * m), where n is the length of the test_list and m is the maximum number of digits in a number in the list.
Auxiliary space: O(m), where m is the maximum number of digits in a number in the list.

Method  5: Using recursion

Step-by-step approach:

• Define a function that takes a number as input.
• Convert the number to a string and check if its digits are in increasing order using a string manipulation technique.
• If the digits are not in increasing order, return False.
• If the number has only one digit or the digits are in increasing order, return True.
• Otherwise, recursively call the function on the number without its first digit.
• If the recursive call returns True and the first digit is less than the second digit, return True.
• Otherwise, return False.
• Initialize an empty list to store the result.
• Loop through each number in the test_list and call the function on it.
• If the function returns True, append the number to the result list.
• Return the result list.

## Python3

 `# initializing list` `test_list ``=` `[``1234``, ``7373``, ``3643``, ``3527``, ``148``]`   `# printing original list` `print``(``"The original list is : "` `+` `str``(test_list))`   `# function to check if digits are in increasing order using recursion` `def` `is_increasing(num):` `    ``str_num ``=` `str``(num)` `    ``if` `len``(str_num) ``=``=` `1``:` `        ``return` `True` `    ``elif` `str_num[``0``] >``=` `str_num[``1``]:` `        ``return` `False` `    ``else``:` `        ``return` `is_increasing(``int``(str_num[``1``:]))`   `# Extracting elements with increasing digits using recursion` `res ``=` `[num ``for` `num ``in` `test_list ``if` `is_increasing(num)]`   `# printing result` `print``(``"Extracted increasing digits : "` `+` `str``(res))`

Output

```The original list is : [1234, 7373, 3643, 3527, 148]
Extracted increasing digits : [1234, 148]```

The time complexity of this method is O(n log n), where n is the length of the test_list.
The auxiliary space complexity of this method is O(log n), which is the maximum depth of the recursion.