Python program to print all Strong numbers in given list

Given a list, write a Python program to print all the strong numbers in that list. Strong Numbers are the numbers whose sum of factorial of digits is equal to the original number. 
Example for checking if number is Strong Number or not.

Input: n = 145
Output: Yes
Explanation: 
Sum of digit factorials = 1! + 4! + 5!
                        = 1 + 24 + 120
                        = 145

Steps for checking number is strong or not :

1) Initialize sum of factorials as 0. 
2) For every digit d, do following
   a) Add d! to sum of factorials.
3) If sum factorials is same as given 
   number, return true.
4) Else return false.

Let’s see the Python program for this problem : 

Python3

# Python3 program to print
# all strong numbers in a list.

# Define a function for calculating
# factorial of a number
def factorial(number):

    fact = 1

    if number == 0 or number == 1 :
        return fact

    for i in range(2, number + 1) :
        fact *= i

    return fact

# Define a function for checking a
# number is strong number or not
def find_strong_numbers(num_list):
    result = []

    # loop till list is not empty
    for num in num_list :
        sum = 0
        temp = num

        # loop till number is not zero
        while num != 0 :

            r = num % 10

            # function call
            sum += factorial(r)

            num //= 10

        # check number is strong or not
        if sum == temp:

            # adding number to the list
            result.append(temp)

    # return list of strong numbers
    return result


# Driver Code
if __name__ == "__main__" :

    num_list = [145, 375, 100, 2, 10, 40585, 0]

    # function call
    strong_num_list = find_strong_numbers(num_list)

    # loop till list is not empty
    for strong_num in strong_num_list :
        print(strong_num, end =" ")

Output

145 2 40585 0 

Time complexity: O(len(num_list)*nlog(n))
Auxiliary Space: O(len(num_list))

Alternative approach: Using Math module and list comprehension.

Python3

#importing math module as m
import math as m

# Function to check if a number is strong or not
def is_strong(num):
    sum_1 = sum([m.factorial(int(i)) for i in str(num)])
    return sum_1 == num

# initializing list
num_list = [145, 375, 100, 2, 10, 40585, 0]

strong_num_list = [num for num in num_list if is_strong(num)]
#printing output
print(strong_num_list)

Output

[145, 2, 40585]

Time complexity: O(n*m), where n is the number of elements in the input list and m is the number of digits in the largest number in the list.
Auxiliary Space: O(n), where n is the number of elements in the input list.

Approach#3: Using filter(): The approach checks whether the numbers in the given list are strong numbers or not using the filter() method and a lambda function. It first defines a factorial() function to calculate the factorial of a number. Then, it defines a list lst containing the numbers to be checked. Finally, it applies the lambda function to the lst using the filter() method to filter the strong numbers from the given list.

1. Define a factorial() function to calculate the factorial of a number.
2. Define a list lst containing the numbers to be checked.
3. Apply the lambda function to the lst using the filter() method to filter the strong numbers from the given list.
4. Store the filtered numbers in the strong_nums list.
5. Print the strong_nums list.

Python3

def factorial(n):
    if n == 0 or n == 1:
        return 1
    else:
        return n * factorial(n - 1)


lst = [145, 375, 100, 2, 10, 40585, 0]

strong_nums = list(filter(lambda num: sum(factorial(int(digit))
                                          for digit in str(num)) == num, lst))

print("Strong numbers in the given list are:", strong_nums)

Output

Strong numbers in the given list are: [145, 2, 40585]

Time Complexity: O(nm), n represents the number of elements in the input list, and m represents the maximum number of digits in an element of the input list.
Space Complexity: O(nm)

Approach#4 : Using anonymous function

Define a lambda function to calculate the factorial of a given number. Define another lambda function to check whether a given number is a strong number or not. A number is called a strong number if the sum of the factorial of its digits is equal to the number itself. Create a list of numbers to check for strong numbers. Use the filter function to filter out the strong numbers from the given list of numbers.
Print the list of strong numbers.

Algorithm

1. Define a lambda function for calculating factorial of a number.
2. Define a lambda function for checking if a number is a strong number or not.
3. Initialize a list of numbers to check.
4. Filter out the strong numbers from the list using the filter() function.
5. Print the list of strong numbers.

Python3

factorial = lambda n: 1 if n == 0 else n * factorial(n-1)
is_strong = lambda n: sum(factorial(int(digit)) for digit in str(n)) == n
numbers = [145, 375, 100, 2, 10, 40585, 0]
strong_numbers = list(filter(is_strong, numbers))
print("Strong numbers:", strong_numbers)

Output

Strong numbers: [145, 2, 40585]

Time Complexity: O(n log n), where n is the maximum number in the list. This is because we are iterating over the digits of the numbers and computing their factorials, which takes log(n) time, and we are doing this for each number in the list.

Auxiliary Space: O(1), as we are not using any extra data structure to store the results.