Python – Extract Rear K digits from Numbers

Given an Integer list, extract rear K digits from it.

Input : test_list = [5645, 23567, 34543, 87652, 2342], K = 2 
Output : [45, 67, 43, 52, 42] 
Explanation : Last 2 digits extracted.

Input : test_list = [5645, 23567, 34543, 87652, 2342], K = 4 
Output : [5645, 3567, 4543, 7652, 2342] 
Explanation : Last 4 digits extracted. 
 

Method #1 : Using list comprehension + % operator

In this technique, we modulo each number with 10^K to get the desired last K digits of each number.

The original list is : [5645, 23567, 34543, 87652, 2342]
Rear K digits of elements ? : [645, 567, 543, 652, 342]

Time Complexity: O(n)
Auxiliary Space: O(1)

Method #2 : Using str() + slicing 

In this, we perform task of getting rear elements using list slicing, and str() is used to convert each element to string.

The original list is : [5645, 23567, 34543, 87652, 2342]
Rear K digits of elements ? : [645, 567, 543, 652, 342]

Time Complexity: O(n)
Auxiliary Space: O(1)

Method #3 : Using map() function and lambda expression: 

Algorithm:

1.Initialize a list, test_list, with some integers.
2.Initialize an integer, K, representing the number of digits to extract from the rear of each element in the list.
3.Apply the modulo operator to each element in the test_list with K.
4.Store the result of the above operation in a new list, res.
5.Return the res list.

The original list is : [5645, 23567, 34543, 87652, 2342]
Rear K digits of elements ? : [645, 567, 543, 652, 342]

Time complexity: O(n), where n is the length of the test_list. The map function operates on each element in the test_list in O(1) time, and the list function takes O(n) time to create the final list.

Auxiliary Space: O(n), where n is the length of the test_list. The space required for the res list is O(n) and the space required for the test_list is O(n).

Method #4: Using a for loop and integer division and modulo operator

Step-by-step approach:

• Initialize an empty list to store the result.
• Loop through each element in the original list.
• Use integer division (//) and modulo (%) operator to extract the last K digits of each element.
• Append the extracted digits to the result list.
• Return the result list.

Below is the implementation of the above approach:

The original list is : [5645, 23567, 34543, 87652, 2342]
Rear K digits of elements ? : [645, 567, 543, 652, 342]

Time complexity: O(n), where n is the length of the original list, since we’re looping through each element once.
Auxiliary space: O(n), since we’re creating a new list to store the result.

Method #5: Using list comprehension and string slicing

• Initialize the input list test_list with the given integers.
• Print the original list to confirm the input.
• Initialize the value of K to the given integer value.
• Use list comprehension to iterate over each number in test_list.
• Convert each number to a string using the str() function.
• Use string slicing to extract the last K characters from each string using the [-K:] syntax.
• Convert the resulting substring back to an integer using the int() function.
• Store the resulting integers in a list using the list comprehension syntax.
• Print the resulting list of integers to confirm the output.

The original list is : [5645, 23567, 34543, 87652, 2342]
Rear K digits of elements ? : [645, 567, 543, 652, 342]

time complexity of this method is O(n*K) where n is the length of the list and K is the number of digits to be extracted. 
Auxiliary space complexity is O(n) because the result is stored in a list of size n.