The below function is written to check whether a given three digit number is an Armstrong number. Hint: An “Armstrong number” is an n-digit number that is equal to the sum of the nth powers of its individual digits. Example: 371 is an Armstrong number as 371 = 3^3 +7^3+ 1^3

The below function is written to check whether a given three digit number is an Armstrong number.

Hint: An “Armstrong number” is an n-digit number that is equal to the sum of the nth powers of its individual digits.
Example: 371 is an Armstrong number as 371 = 3^3 +7^3+ 1^3

Source:

	'''
	Created on 24-Aug-2019
	@author: Anonymous
	'''
	#PF-Tryout
	def find_armstrong(number):
	temp=0
	x=number #
	while(number!=0):
	remainder=number%10
	# This Statement changing the value of number variable so
	number=number//10
	# For keeping original Number we took it in a variable named a "x"
	temp+=(remainder*remainder*remainder)
	if(x==temp):
	return True
	return False
	number=371
	if(find_armstrong(number)):
	print(number,"is an Armstrong number")
	else:
	print(number,"is not an Armstrong number")

view raw #PF-Assgn-45.py hosted with ❤ by GitHub

Write a python function find_duplicates(), which accepts a list of numbers and returns another list containing all the duplicate values in the input list. If there are no duplicate values, it should return an empty list.

	#PF-Assgn-44
	def find_duplicates(list_of_numbers):
	#start writing your code here
	x=set(list_of_numbers)
	y=[]
	dup=[]
	count=0
	for i in x:
	y.append(i)
	for i in y:
	for j in list_of_numbers:
	if(j==i):
	count+=1
	if count>=2:
	dup.append(i)
	break
	count=0
	return dup
	list_of_numbers=[1,2,3]
	list_of_duplicates=find_duplicates(list_of_numbers)
	print(list_of_duplicates)

view raw #PF-Assign-44.py hosted with ❤ by GitHub

Write a python function find_smallest_number() which accepts a number n and returns the smallest number having n divisors. Handle the possible errors in the code written inside the function.

Source Code:-

	'''
	Created on 19-Aug-2019
	@author: Anonymous
	'''
	#PF-Assgn-43
	def find_factors(num):
	#Accepts a number and returns the list of all the factors of a given number
	factors = []
	for i in range(1,(num+1)):
	if(num%i==0):
	factors.append(i)
	return factors
	def find_smallest_number(num):
	i=int(1)
	while(True):
	x=find_factors(i)
	if(len(x)==num):
	print(x)
	break
	else:
	i=i+int(1)
	return x[-1]
	#start writing your code here
	num=16
	print("The number of divisors :",num)
	result=find_smallest_number(num)
	print("The smallest number having",num," divisors:",result)

view raw #PF-Assign-43.py hosted with ❤ by GitHub

Given a number n, write a program to find the sum of the largest prime factors of each of nine consecutive numbers starting from n. g(n) = f(n) + f(n+1) + f(n+2) + f(n+3) + f(n+4) + f(n+5) + f(n+6) + f(n+7) + f(n+8) where, g(n) is the sum and f(n) is the largest prime factor of n For example, g(10)=f(10)+f(11)+f(12)+f(13)+f(14)+f(15)+f(16)+f(17)+f(18)=5 + 11 + 3 + 13 + 7 + 5 + 2 + 17 + 3 =66

Given a number n, write a program to find the sum of the largest prime factors of each of nine consecutive numbers starting from n.
g(n) = f(n) + f(n+1) + f(n+2) + f(n+3) + f(n+4) + f(n+5) + f(n+6) + f(n+7) + f(n+8)
where, g(n) is the sum and f(n) is the largest prime factor of n

For example,
g(10)=f(10)+f(11)+f(12)+f(13)+f(14)+f(15)+f(16)+f(17)+f(18) 
        =5 + 11 + 3 + 13 + 7 + 5 + 2 + 17 + 3 
        =66 

 Source Code:-

	'''
	Given a number n, write a program to find the sum of the largest prime factors of each of nine consecutive numbers starting from n.
	g(n) = f(n) + f(n+1) + f(n+2) + f(n+3) + f(n+4) + f(n+5) + f(n+6) + f(n+7) + f(n+8)
	where, g(n) is the sum and f(n) is the largest prime factor of n
	For example,
	g(10)=f(10)+f(11)+f(12)+f(13)+f(14)+f(15)+f(16)+f(17)+f(18)
	=5 + 11 + 3 + 13 + 7 + 5 + 2 + 17 + 3
	=66
	'''
	#PF-Assgn-42
	def find_factors(num):
	#Accepts a number and returns the list of all the factors of a given number
	factors = []
	for i in range(2,(num+1)):
	if(num%i==0):
	factors.append(i)
	return factors
	def is_prime(num, i):
	#Accepts the number num and num/2 --> i and returns True if the number is prime ,else returns False
	if(i==1):
	return True
	elif(num%i==0):
	return False;
	else:
	return(is_prime(num,i-1))
	def find_largest_prime_factor(list_of_factors):
	large=[]
	for i in list_of_factors:
	if is_prime(i,i//2)==True:
	large.append(i)
	return max(large)
	#Accepts the list of factors and returns the largest prime factor
	def find_f(num):
	#Accepts the number and returns the largest prime factor of the number
	f=find_factors(num)
	l=find_largest_prime_factor(f)
	return l
	def find_g(num):
	#Accepts the number and returns the sum of the largest prime factors of the 9 consecutive numbers starting from the given number
	sum=0
	consicutive=[i for i in range(num,num+9)]
	for i in consicutive:
	largest_prime_factor=find_f(i)
	sum=sum+largest_prime_factor
	return sum
	#Note: Invoke function(s) from other function(s), wherever applicable.
	print(find_g(10))

view raw #PF-Assign-42.py hosted with ❤ by GitHub

A 10-substring of a number is a substring of its digits that sum up to 10. For example, the 10-substrings of the number 3523014 are: 3523014, 3523014, 3523014, 3523014

A 10-substring of a number is a substring of its digits that sum up to 10.

For example, the 10-substrings of the number 3523014 are:
3523014, 3523014, 3523014, 3523014

Write a python function, find_ten_substring(num_str) which accepts a string and returns the list of 10-substrings of that string.

Handle the possible errors in the code written inside the function.

	#PF-Assgn-41
	def find_ten_substring(num_str):
	m=[]
	l=[]
	for i in range(0,len(num_str)):
	for j in range(i,len(num_str)):
	m.append(num_str[i:j+1])
	for k in set(m):
	s=0
	for b in range(0,len(k)):
	s=s+int(k[b])
	if(s==10 and b+1==len(k)):
	l.append(k)
	return l
	#Remove pass and write your logic here
	num_str="2825302"
	print("The number is:",num_str)
	result_list=find_ten_substring(num_str)
	print(result_list)

view raw #PF-Assign-41.py hosted with ❤ by GitHub

Write a recursive function, is_palindrome() to find out whether a string is a palindrome or not. The function should return true, if it is a palindrome. Else it should return false.

Source Code:-

	#PF-Assgn-40
	def is_palindrome(word):
	word=word.lower()
	if(len(word)==1):
	return True
	elif(len(word)==2):
	if(word[0]==word[1]):
	return True
	else:
	return False
	elif(len(word)>2 and word[0]==word[-1]):
	word=word[1:-1]
	result=is_palindrome(word)
	if(result):
	return True
	else:
	return False
	else:
	return False
	#Remove pass and write your logic here
	#Provide different values for word and test your program
	result=is_palindrome("mm")
	if(result):
	print("The given word is a Palindrome")
	else:
	print("The given word is not a Palindrome")

view raw #PF-Assgn-40.py hosted with ❤ by GitHub

Represent a small bilingual (English-Swedish) glossary given below as a Python dictionary

{"merry":"god", "christmas":"jul", "and":"och", "happy":"gott", "new":"nytt", "year":"ar"} 

and use it to translate your Christmas wishes from English into Swedish.

That is, write a python function translate() that accepts the bilingual dictionary and a list of English words (your Christmas wish) and returns a list of equivalent Swedish words. 

	#PF-Exer-23
	def translate(bilingual_dict,english_words_list):
	#Write your logic here
	swedish_words_list=[]
	for i in english_words_list:
	for key in bilingual_dict:
	if(key==i):
	swedish_words_list.append(bilingual_dict[key])
	return swedish_words_list
	bilingual_dict= {"merry":"god", "christmas":"jul", "and":"och", "happy":"gott", "new":"nytt", "year":"ar"}
	english_words_list=["merry","christmas"]
	print("The bilingual dict is:",bilingual_dict)
	print("The english words are:",english_words_list)
	swedish_words_list=translate(bilingual_dict, english_words_list)
	print("The equivalent swedish words are:",swedish_words_list)

view raw #PF-Exer-23.py hosted with ❤ by GitHub