Write a python function, find_correct() which accepts a dictionary and returns a list as per the rules mentioned below. The input dictionary will contain correct spelling of a word as key and the spelling provided by a contestant as the value.

Write a python function, find_correct() which accepts a dictionary and returns a list as per the rules mentioned below.
The input dictionary will contain correct spelling of a word as key and the spelling provided by a contestant as the value.

The function should identify the degree of correctness as mentioned below:
CORRECT, if it is an exact match
ALMOST CORRECT, if no more than 2 letters are wrong
WRONG, if more than 2 letters are wrong or if length (correct spelling versus spelling given by contestant) mismatches.

and return a list containing the number of CORRECT answers, number of ALMOST CORRECT answers and number of WRONG answers. 
Assume that the words contain only uppercase letters and the maximum word length is 10.

Also write the pytest test cases to test the program.

#PF-Assgn-48

def find_correct(word_dict):
    #start writing your code here
    key=[]
    value=[]
    count=0
    correct=0
    wrong=0
    atmost=0
    result=[]
    for i,j in word_dict.items():
            key.append(i)
            value.append(j)
    for i in range(len(key)):
        if(len(key[i])==len(value[i]) and key[i]==value[i]):
            correct+=1
        elif((len(key[i])==len(value[i]))==False):
            wrong+=1
        else:
            for j in range(len(key[i])):
                if((key[i][j]==value[i][j])==False):
                    count+=1
                    if(count>2):
                        wrong+=1
                        break
            if(count<=2):
                atmost+=1
            count=0
           
           
    result=[correct,atmost,wrong]
    return result
       


word_dict={"THEIR": "THEIR","BUSINESS":"BISINESS","WINDOWS":"WINDMILL","WERE":"WEAR","SAMPLE":"SAMPLE"}
print(find_correct(word_dict))

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