Sometimes, while programming, we have a problem in which we might need to perform certain bitwise operations among list elements. This is an essential utility as we come across bitwise operations many times. Let’s discuss certain ways in which this task can be performed.
List Inversions using map() + lambda + “~” operator
The above functions can be combined to perform this task. We can employ Python map() to accumulate the result of the Inversion logic specified by the Python lambda function.
Python3
# Python3 code to demonstrate working of# List Inversions# Using map() + lambda + "~" operator# initializing listtest_list = [7, 8, 9, 1, 10, 7]# printing original listprint("The original list is : " + str(test_list))# List Inversions# Using map() + lambda + "~" operatorres = list(map(lambda x: ~x, test_list))# printing resultprint("The Bitwise Inversions of list elements are : " + str(res)) |
The original list is : [7, 8, 9, 1, 10, 7] The Bitwise Inversions of list elements are : [-8, -9, -10, -2, -11, -8]
Time Complexity: O(n) where n is the number of elements in the string list. The map() + lambda + “~” operator is used to perform the task and it takes O(n) time.
Auxiliary Space: O(n) additional space of size n is created where n is the number of elements in the string list.
List Inversions using map() + operator.invert
This task can also be performed using this method. In this, the task performed by the Python lambda function in the above method is performed using the operator for cumulative Inversion operation.
Python3
# Python 3 code to demonstrate working of# List Inversions# Using map() + operator.invertfrom operator import invert# initializing listtest_list = [7, 8, 9, 1, 10, 7]# printing original listprint("The original list is : " + str(test_list))# List Inversions# Using map() + operator.invertres = list(map(invert, test_list))# printing resultprint("The Bitwise Inversions of list elements are : " + str(res)) |
The original list is : [7, 8, 9, 1, 10, 7] The Bitwise Inversions of list elements are : [-8, -9, -10, -2, -11, -8]
List Inversions using for loop
- First, define a list of integers my_list containing five elements.
- Define an empty list called inverted_list.
- Use a for loop to iterate over each element in my_list, invert it using the tilde operator, and append the result to inverted_list.
- Print the inverted_list to the console.
Python3
# give input listmy_list = [1, 2, 3, 4, 5] # take empty listinverted_list = [] # iteratefor x in my_list: # using bitwise operator and append get the inverted list inverted_list.append(~x)# print inverted list outputprint(inverted_list) |
[-2, -3, -4, -5, -6]
Time complexity: O(N), where N is the length of the input list. This is because the for loop iterates over each element in the list once, and the operations inside the loop take constant time.
Auxiliary Space: O(N), we create a new list inverted_list to store the inverted elements. The size of this list is the same as the size of the input list.
List Inversions using numpy library
1. Define a list of integers `test_list`.
2. Print the original list.
3. Compute the bitwise NOT of each element in `test_list` using the `np.invert()` function from the `numpy` library.
a. Convert `test_list` to a `numpy` array using the `np.array()` function.
b. Call the `np.invert()` function on the array to compute the bitwise NOT of each element.
4. Convert the resulting `numpy` array to a Python list using the `tolist()` method.
5. Print the inverted list.
Python3
import numpy as nptest_list = [7, 8, 9, 1, 10, 7]# printing original listprint("The original list is : " + str(test_list))inverted_list = np.invert(test_list).tolist()print("The Bitwise Inversions of \ list elements are : " + str(inverted_list)) |
Output:
The original list is : [7, 8, 9, 1, 10, 7] The Bitwise Inversions of list elements are : [-8, -9, -10, -2, -11, -8]
Time complexity: The np.invert() function from the Numpy library is applied to the entire list in one call, which takes O(n) time. The tolist() method also takes O(n) time because it creates a new list with the same elements as the Numpy array. Therefore, the overall time complexity is O(n).
Auxiliary Space: The Numpy array created from the list takes O(n) space since it stores all the elements in memory. The tolist() method also creates a new list with the same number of elements, so it also takes O(n) space. Therefore, the overall space complexity is O(n).
