# Python List Comprehension | Three way partitioning of an array around a given range

Given an array and a range [lowVal, highVal], partition the array around the range such that array is divided in three parts. 1) All elements smaller than lowVal come first. 2) All elements in range lowVal to highVal come next. 3) All elements greater than highVal appear in the end. The individual elements of three sets can appear in any order. Examples:

```Input: arr = [1, 14, 5, 20, 4, 2, 54, 20, 87, 98, 3, 1, 32]
lowVal = 14, highVal = 20
Output: arr = [1, 5, 4, 2, 3, 1, 14, 20, 20, 54, 87, 98, 32]

Input: arr = [1, 14, 5, 20, 4, 2, 54, 20, 87, 98, 3, 1, 32]
lowVal = 20, highVal = 20
Output: arr = [1, 14, 5, 4, 2, 3, 1, 20, 20, 54, 87, 98, 32] ```

We have existing solution for this problem please refer Three way partitioning of an array around a given range link. We can solve this problem quickly in python using List Comprehension. Approach is simple,

1. Separate list in three parts, first one will contain elements less than lowVal, second will contain elements between lowVal and highVal, third will contain elements greater than highVal.
2. Concatenate all three parts together.

## Python3

 `# Function for Three way partitioning of an` `# array around a given range`   `def` `threeWay(``input``, lowVal, highVal):`   `# separate input list in three parts` `     ``first ``=` `[ num ``for` `num ``in` `input` `if` `num``=``lowVal ``and` `num<``=``highVal) ]` `     ``third ``=` `[ num ``for` `num ``in` `input` `if` `num>highVal ]`   `# concatenate all three parts` `     ``print``(first ``+` `second ``+` `third)`   `# Driver program` `if` `__name__ ``=``=` `"__main__":` `    ``input` `=` `[``1``, ``14``, ``5``, ``20``, ``4``, ``2``, ``54``, ``20``, ``87``, ``98``, ``3``, ``1``, ``32``]` `    ``lowVal ``=` `14` `    ``highVal ``=` `20` `    ``threeWay(``input``, lowVal, highVal)`

Output:

`[1, 5, 4, 2, 3, 1, 14, 20, 20, 54, 87, 98, 32]`

#### Approach#2: Using filter()+lambda()

In this approach, we first use the filter() function along with a lambda function to filter out the elements from the list that are less than lowVal. Similarly, we filter out the elements that are greater than highVal. Finally, we concatenate the filtered lists along with the list comprehension.

#### Algorithm

1. Create three lists using filter() and lambda function to filter out elements less than lowVal, elements between lowVal and highVal, and elements greater than highVal respectively.
2. Concatenate these three lists to form the final list.

## Python3

 `arr ``=` `[``1``, ``14``, ``5``, ``20``, ``4``, ``2``, ``54``, ``20``, ``87``, ``98``, ``3``, ``1``, ``32``]` `lowVal ``=` `14` `highVal ``=` `20`   `arr ``=` `list``(``filter``(``lambda` `x: x < lowVal, arr)) ``+` `list``(``filter``(``lambda` `x: lowVal <``=` `x <``=` `highVal, arr)) ``+` `list``(``filter``(``lambda` `x: x > highVal, arr))` `print``(arr)`

Output

```[1, 5, 4, 2, 3, 1, 14, 20, 20, 54, 87, 98, 32]
```

Time complexity: O(n), The filter() function has a time complexity of O(n). We use filter() three times, so the time complexity of filter() is 3*O(n), which is O(n). Concatenating the three lists has a time complexity of O(n). Therefore, the total time complexity of the code is O(n).
Space complexity: O(n) We use filter() to create three lists, each containing at most n elements. The size of the final list is n. Therefore, the space complexity of the code is O(n).

Whether you're preparing for your first job interview or aiming to upskill in this ever-evolving tech landscape, GeeksforGeeks Courses are your key to success. We provide top-quality content at affordable prices, all geared towards accelerating your growth in a time-bound manner. Join the millions we've already empowered, and we're here to do the same for you. Don't miss out - check it out now!