Python Lab Report

Exercise Number: [1]

Date: 5/12/2024

Course Title: 24Z110 Python Programming Lab

Student Name: SUGANTH V

Roll Number: 24Z368

Objective:

The objective of this lab is to understand and apply fundamental Python

programming concepts, including functions, data types, control structures
(such as loops and conditionals), and operations on strings and numbers.

Experiment:

1. Problem Statement:

Write a Python function to find the maximum of three numbers. The

function should take three input numbers and return the largest number.

2. Algorithm/Logic:

Define a function named max_of_three.

The function should accept three numbers as arguments.

Use Python's built-in max() function to find the largest of the three
numbers.

Return the largest number.

3. Code:

def max_of_three(a, b, c):

return max(a, b, c)

4. Execution Process:

I defined the function max_of_three() that accepts three numbers.

I used ’s built-in max() function to compute the maximum.

To test the function, I provided different sets of inputs (e.g., 10, 20, 5) and
verified the output by printing the result.

Observations:

The function works as expected, correctly returning the largest of the

three input numbers.

I tested the function with various combinations of numbers, including

positive, negative, and equal numbers.

Output:

print(max_of_three(10, 20, 5)) # Output: 20

print(max_of_three(-1, -5, -3)) # Output: -1

print(max_of_three(3, 3, 3)) # Output: 3

Conclusion:

This task demonstrated how to define a simple function and use built-in
functions like max() for common operations. It reinforced concepts such as
function creation, argument passing, and utilizing ’s extensive standard
library.

Lab Report
Exercise Number: [2]

Date: 5/12/2024

Course Title: 24Z110 Programming Lab

Student Name: SUGANTH V

Roll Number: 24Z368

Objective:

The objective of this lab is to practice defining and using functions to

perform mathematical and string operations, including working with lists,
loops, conditionals, and built-in functions.

Experiment:

1. Problem Statement:

Write a function to sum all the numbers in a list. The function should take
a list of numbers as input and return the sum of all the numbers in the list.

2. Algorithm/Logic:

Define a function sum_of_list() that takes a list of numbers as input.

Use 's built-in sum() function to calculate the sum of the list elements.

Return the sum.

3. Code:

def sum_of_list(lst):
 return sum(lst)

4. Execution Process:

I defined the function sum_of_list() that accepts a list of numbers.

I used 's sum() function to compute the total sum.

To test the function, I provided different lists (e.g., [1, 2, 3, 4]) and printed
the result to verify correctness.

Observations:

The function worked as expected and returned the correct sum of all the
numbers in the list.

It handled both small and large lists effectively.

Output:

print(sum_of_list([1, 2, 3, 4])) # Output: 10

print(sum_of_list([10, 20, 30])) # Output: 60

print(sum_of_list([5, -5, 10])) # Output: 10

Conclusion:

This task helped reinforce the use of 's built-in functions like sum() to
perform common operations on lists. It also demonstrated how to handle
lists effectively and compute aggregates.

Lab Report

Exercise Number: [3]

Date: 5/12/2024

Course Title: 24Z110 Programming Lab

Student Name: SUGANTH V

Roll Number: 24Z368

Objective:

The objective of this lab is to practice defining functions that work with
conditionals and range checks, using basic logical operations.

Experiment:

1. Problem Statement:

Write a function to check whether a number falls within a given range.

The function should accept three parameters: a number, a start value, and
an end value. It should return True if the number falls within the range
(inclusive) and False otherwise.

2. Algorithm/Logic:

Define a function is_in_range() that accepts three arguments: the number,

the start of the range, and the end of the range.

Use conditional checks to verify if the number is greater than or equal to

the start value and less than or equal to the end value.

Return True if the condition is satisfied, otherwise return False.

3. Code:

def is_in_range(num, start, end):

return start <= num <= end

4. Execution Process:
I defined the function is_in_range() which checks if the number falls
between the start and end values (inclusive).

I tested the function using various inputs like 5, 1, 10 and verified the
output.

Observations:

The function worked as expected for all valid inputs.

I tested edge cases such as when the number is equal to the start or end
of the range, and the function handled them correctly.

Output:

print(is_in_range(5, 1, 10)) # Output: True

print(is_in_range(0, 1, 10)) # Output: False

print(is_in_range(10, 1, 10)) # Output: True

Conclusion:

This task provided an opportunity to use conditionals and range checks

effectively. I reinforced the concept of using comparison operators to
perform logical checks in .

Lab Report

Exercise Number: [4]

Date: 5/12/2024
Course Title: 24Z110 Programming Lab

Student Name: SUGANTH V

Roll Number: 24Z368

Objective:

To practice string manipulation, including checking the case of characters

and counting uppercase and lowercase characters.

Experiment:

1. Problem Statement:

Write a function that accepts a string and calculates the number of

uppercase and lowercase letters in the string. The function should return
both counts.

2. Algorithm/Logic:

Define a function count_case() that takes a string as input.

Initialize counters for uppercase and lowercase characters.

Loop through each character in the string, checking if it is uppercase using

the isupper() method or lowercase using the islower() method.

Return the counts of uppercase and lowercase characters.

3. Code:

def count_case(s):

upper = 0

lower = 0
 for char in s:

if char.isupper():

upper += 1

elif char.islower():

lower += 1

return f'No. of Upper case characters: {upper}\nNo. of Lower case

Characters: {lower}'

4. Execution Process:

I defined the function count_case() which iterates through each character

in the input string.

I used string methods isupper() and islower() to check each character’s

case.

I tested the function with a sample string 'The quick Brow Fox' and printed
the result to verify correctness.

Observations:

The function correctly counted both uppercase and lowercase characters

in the string.

It handled mixed case strings, as well as edge cases like an empty string
or strings without uppercase or lowercase characters.

Output:

print(count_case("The quick Brow Fox"))

# Output:

# No. of Upper case characters: 3

# No. of Lower case Characters: 12

Conclusion:

This task helped reinforce the use of string manipulation functions and
conditional checks to solve problems involving text processing. I practiced
counting specific types of characters using ’s built-in string methods.

Lab Report

Exercise Number: [5]

Date: 5/12/2024
Course Title: 24Z110 Programming Lab

Student Name: SUGANTH V

Roll Number: 24Z368

Objective:

The objective of this lab is to practice mathematical operations and

decision-making logic, specifically checking if a number is prime.

Experiment:

1. Problem Statement:

Write a function that takes a number as a parameter and checks whether

the number is prime or not. The function should return True if the number
is prime and False otherwise.

2. Algorithm/Logic:

Define a function is_prime() that accepts a number as input.

If the number is less than or equal to 1, return False (since prime numbers
are greater than 1).

Loop through all numbers from 2 to the square root of the number and
check if the number is divisible by any of them.

If the number is divisible by any number in the loop, return False.

Otherwise, return True.

3. Code:

def is_prime(num):

if num <= 1:

return False

for i in range(2, int(num ** 0.5) + 1):

 if num % i == 0:

return False

return True

4. Execution Process:

I defined the is_prime() function and tested it with various inputs,

including numbers like 2, 10, 13, etc.

I used a loop to check if any number from 2 to the square root of the given
number divides it.

I verified the correctness by testing with both prime

Exercise Number: [6]

Date: 5/12/2024

Course Title: 24Z110 Programming Lab

Student Name: SUGANTH V

Roll Number: 24Z368

Objective:

The objective of this lab is to practice string manipulation, specifically

checking if a string is a pangram, meaning it contains every letter of the
alphabet at least once.

Experiment:

1. Problem Statement:

Write a function to check whether a string is a pangram or not. A

pangram is a sentence that contains every letter of the alphabet at least
once. For example, "The quick brown fox jumps over the lazy dog".

2. Algorithm/Logic:

Define a function is_pangram() that takes a string as input.

Convert the string to lowercase to ensure case insensitivity.

Remove any non-alphabetic characters (like spaces or punctuation).

Check if the set of characters in the string contains all the letters of the
English alphabet.

Return True if all 26 letters are found, otherwise return False.

3. Code:

import string

def is_pangram(s):

s = s.lower()

alphabet_set = set(string.ascii_lowercase)

return set(s) >= alphabet_set

4. Execution Process:

I defined the function is_pangram() and tested it with strings like "The
quick brown fox jumps over the lazy dog" and "Hello World!".

I used ’s set() function to handle the letters efficiently and compared it to

the set of the alphabet.

I verified the output by testing both pangrams and non-pangrams.

Observations:

The function correctly identified whether a string was a pangram.

I tested both uppercase and lowercase inputs, and the function worked in
all cases.

Output:

print(is_pangram("The quick brown fox jumps over the lazy dog")) #

Output: True

print(is_pangram("Hello World!")) # Output: False

Conclusion:

This task helped me understand how to work with strings and sets in . The
use of set() provided an efficient way to compare the characters of a
string to the complete alphabet, demonstrating how to check for
conditions like a pangram.

Lab Report

Exercise Number: [7]

Date: 5/12/2024

Course Title: 24Z110 Programming Lab

Student Name: SUGANTH V

Roll Number: 24Z368

Objective:

The objective of this lab is to practice string manipulation and sorting

techniques. Specifically, to handle input and output formats for hyphen-
separated sequences of words.

Experiment:

1. Problem Statement:

Write a program that accepts a hyphen-separated sequence of words as

input and prints the words in a hyphen-separated sequence after sorting
them alphabetically.

2. Algorithm/Logic:

Accept a string of hyphen-separated words as input.

Split the string into a list of words using the split() function with '-' as the
delimiter.

Sort the list of words alphabetically using ’s built-in sorted() function.

Join the sorted words back together with a hyphen and print the result.

3. Code:

def sort_hyphenated_words():

input_str = input("Enter a hyphen-separated sequence of words: ")

words = input_str.split('-')

words.sort()

print('-'.join(words))
4. Execution Process:

I implemented the sort_hyphenated_words() function to accept the input

as a hyphen-separated string.

I split the string into a list of words, sorted them alphabetically, and joined
them back into a single string.

I tested the function with inputs like 'green-red-yellow-black-white' to

verify the correct order.

Observations:

The program correctly sorted the words in the input string.

The function handled various combinations of input, including strings with

uppercase and lowercase letters.

Output:

Enter a hyphen-separated sequence of words: green-red-yellow-black-

white

# Output: black-green-red-white-yellow

Conclusion:

This task helped me practice string manipulation and sorting techniques.

By utilizing ’s string methods and the built-in sorted() function, I was able
to sort and reformat a hyphen-separated list of words efficiently.

Lab Report

Exercise Number: [8]

Date: 5/12/2024

Course Title: 24Z110 Programming Lab

Student Name: SUGANTH V

Roll Number: 24Z368

Objective:

The objective of this lab is to practice defining and calling functions within
other functions, as well as to reinforce the concept of function scope.

Experiment:

1. Problem Statement:

Write a program to access a function inside a function. The program

should define one function that calls another function to perform a task.

2. Algorithm/Logic:

Define a main function, outer_function(), that calls another function,

inner_function(), from within it.

The inner function should perform a simple task, such as printing a

message or performing a calculation.

The outer function should invoke the inner function and potentially use its
result.

3. Code:

def outer_function():

def inner_function():

print("Hello from the inner function!")

inner_function()

outer_function()
4. Execution Process:

I defined an outer_function() which contains an inner_function().

I invoked the inner function from within the outer function to demonstrate
nested function calls.

I tested the program by running the outer_function() and observing the

output.

Observations:

The program correctly executed the inner function from within the outer
function.

The concept of accessing a function within another function was

demonstrated successfully.

Output:

Hello from the inner function!

Conclusion:

This task demonstrated the concept of nested functions and the scope of
functions in . I learned how functions can be defined and called within
other functions, which is useful for organizing code logically.

Lab Report

Exercise Number: [9]

Date: 5/12/2024

Course Title: 24Z110 Programming Lab

Student Name: SUGANTH V

Roll Number: 24Z368

Objective:

The objective of this lab is to practice finding the largest item in a given
list using 's built-in functions.

Experiment:

1. Problem Statement:

Write a function to find the largest item from a given list. The function
should take a list of numbers and return the largest value.

2. Algorithm/Logic:

Define a function largest_item() that takes a list as input.

Use 's built-in max() function to find the largest number in the list.

Return the largest number.

3. Code:

def largest_item(lst):

return max(lst)

4. Execution Process:

I defined the function largest_item() that accepts a list of numbers.

I used the max() function to find the largest value.

I tested the function with different lists, such as [10, 20, 5] and [7, 3, 9,
12], to ensure it works correctly.

Observations:

The function correctly identified the largest number in the list.

I tested the function with both positive and negative numbers, and it
worked as expected.

Output:

print(largest_item([10, 20, 5])) # Output: 20

print(largest_item([7, 3, 9, 12])) # Output: 12

Conclusion:

This task reinforced the use of 's built-in max() function to find the largest
item in a list. I practiced working with lists and utilizing efficient built-in
functions.

Exercise Number: [10]

Date: 5/12/2024

Course Title: 24Z110 Programming Lab

Student Name: SUGANTH V

Roll Number: 24Z368

Objective:

The objective of this lab is to practice defining and using functions to

simulate attendance marking by checking if a student is present or absent
based on a roll number.

Experiment:

1. Problem Statement:

Define a function that accepts a roll number and returns whether the
student is present or absent. The function will simulate a simple
attendance system.

2. Algorithm/Logic:

Define a function check_attendance() that takes a roll number as input.

If the roll number is in a predefined list of present students, return

"Present".

Otherwise, return "Absent".

3. Code:

def check_attendance(roll_number):

present_students = [101, 102, 103, 104, 105]

if roll_number in present_students:

return "Present"

else:

return "Absent"

4. Execution Process:

I created a list of roll numbers for present students.

I tested the function with different roll numbers to check if it correctly

identifies if the student is present or absent.

Observations:
The function correctly identified if the roll number was present or absent
in the list.

I tested with multiple roll numbers and the results matched the expected
outputs.

Output:

print(check_attendance(103)) # Output: Present

print(check_attendance(106)) # Output: Absent

Conclusion:

This task helped me practice working with lists and conditionals. I learned
how to check for a student’s attendance using roll numbers, simulating an
attendance system.

Lab Report

Exercise Number: [11]

Date: 5/12/2024
Course Title: 24Z110 Programming Lab

Student Name: SUGANTH V

Roll Number: 24Z368

Objective:

The objective of this lab is to practice string manipulation by counting

vowels and consonants in a word.

Experiment:

1. Problem Statement:

Define a function that counts the number of vowels and consonants in a

given word.

2. Algorithm/Logic:

Define a function count_vowels_consonants() that takes a string as input.

Iterate through the string and check each character.

Count vowels (a, e, i, o, u) and consonants separately.

Return the counts of vowels and consonants.

3. Code:

def count_vowels_consonants(word):

vowels = "aeiou"

word = word.lower()

vowel_count = 0

consonant_count = 0
 for char in word:

if char.isalpha():

if char in vowels:

vowel_count += 1

else:

consonant_count += 1

return vowel_count, consonant_count

4. Execution Process:

I implemented the function to count vowels and consonants separately.

I tested it with various words such as "" and "Programming" to validate

the results.

Observations:

The function correctly counted the vowels and consonants in each word.

It successfully handled both uppercase and lowercase letters.

Output:

vowels, consonants = count_vowels_consonants("Programming")

print(f"Vowels: {vowels}, Consonants: {consonants}") # Output: Vowels:

3, Consonants: 7

Conclusion:

This task helped me practice string manipulation and condition checking. I

successfully counted vowels and consonants in a string and learned how
to handle characters based on their type (alphabetic).

Lab Report

Exercise Number: [12]

Date: 5/12/2024

Course Title: 24Z110 Programming Lab

Student Name: SUGANTH V

Roll Number: 24Z368

Objective:

The objective of this lab is to practice converting lowercase words to

uppercase.

Experiment:

1. Problem Statement:

Define a function that accepts a word in lowercase and returns the word in
uppercase.

2. Algorithm/Logic:

Define a function to_uppercase() that takes a string as input.

Use ’s upper() method to convert the string to uppercase.

Return the converted string.

3. Code:

def to_uppercase(word):

return word.upper()

4. Execution Process:

I tested the function with several lowercase words like "hello", "world",
and "".

The function correctly returned the uppercase version of the input string.

Observations:

The function worked as expected, converting all characters to uppercase.

It handled multiple test cases without issues.

Output:

print(to_uppercase("hello")) # Output: HELLO

Conclusion:

This task helped me practice using string methods. I successfully used

the upper() method to convert a string to uppercase.

Lab Report

Exercise Number: [13]

Date: 5/12/2024

Course Title: 24Z110 Programming Lab

Student Name: SUGANTH V

Roll Number: 24Z368

Objective:

The objective of this lab is to practice calculating the area of a circle using
the radius.

Experiment:

1. Problem Statement:

Define a function that accepts the radius of a circle and returns its area.

2. Algorithm/Logic:

Define a function circle_area() that takes the radius as input.

Use the formula for the area of a circle,

π×radius square, to calculate the area.

Return the calculated area.

3. Code:

import math

def circle_area(radius):

return math.pi * radius ** 2

4. Execution Process:

I tested the function with different values of the radius, such as 5 and 10,
to calculate the corresponding areas.

The math.pi constant was used to ensure precision.

Observations:

The function correctly calculated the area for various radii.

It produced accurate results based on the mathematical formula.

Output:

print(circle_area(5)) # Output: 78.53981633974483

Conclusion:

This task helped me understand how to use 's math module and apply
mathematical formulas in programming. I successfully calculated the area
of a circle.

Lab Report

Exercise Number: [14]

Date: 5/12/2024

Course Title: 24Z110 Programming Lab

Student Name: SUGANTH V

Roll Number: 24Z368

Objective:

The objective of this lab is to practice determining if a number is even or

odd.

Experiment:

1. Problem Statement:

Define a function that accepts a number and returns whether the number
is even or odd.

2. Algorithm/Logic:

Define a function check_even_odd() that takes an integer as input.

Use the modulo operator % to check if the number is divisible by 2.

Return "Even" if the number is divisible by 2, otherwise return "Odd".

3. Code:

def check_even_odd(num):

if num % 2 == 0:

return "Even"

else:

return "Odd"

4. Execution Process:

I tested the function with both even and odd numbers.

The function worked as expected for various inputs.

Observations:

The function correctly identified whether the number was even or odd.

It handled both positive and negative integers.

Output:
print(check_even_odd(4)) # Output: Even

print(check_even_odd(7)) # Output: Odd

Conclusion:

This task helped me understand how to use conditional statements and

the modulo operator to check if a number is even or odd.

Lab Report

Exercise Number: [15]

Date: 5/12/2024

Course Title: 24Z110 Programming Lab

Student Name: SUGANTH V

Roll Number: 24Z368

Objective:

The objective of this lab is to practice writing a function that accepts two
numbers as arguments and returns their sum.

Experiment:

1. Problem Statement:

Write a function that accepts two numbers as arguments and returns the
sum of those numbers.

2. Algorithm/Logic:

Define a function sum_of_numbers() that takes two numbers as

arguments.

Return the sum of the two numbers.

3. Code:

def sum_of_numbers(num1, num2):

return num1 + num2

4. Execution Process:

I defined the sum_of_numbers() function, taking two input numbers.

I tested the function with different pairs of numbers, such as (10, 20) and
(5, 5).

Observations:

The function correctly computed the sum of the two numbers.

It worked for both positive and negative numbers.

Output:

print(sum_of_numbers(10, 20)) # Output: 30

print(sum_of_numbers(5, -5)) # Output: 0

Conclusion:
This task helped me practice basic function creation and arithmetic
operations. I successfully wrote a function to calculate the sum of two
numbers.

Lab Report

Exercise Number: [16]

Date: 5/12/2024

Course Title: 24Z110 Programming Lab

Student Name: SUGANTH V

Roll Number: 24Z368

Objective:

The objective of this lab is to practice working with dictionaries in .

Experiment:

1. Problem Statement:

Write a function that returns a dictionary. The dictionary should contain

key-value pairs of some sample data.

2. Algorithm/Logic:

Define a function create_dictionary() that returns a dictionary.

The dictionary should contain some predefined sample key-value pairs,

such as name, age, and city.

3. Code:

def create_dictionary():

sample_dict = {

"name": "John",

"age": 25,

"city": "New York"

return sample_dict

4. Execution Process:

I created a dictionary with keys "name", "age", and "city".

The function was tested by printing the dictionary to verify its correctness.

Observations:

The function correctly returned a dictionary with sample data.

The dictionary was easy to manipulate for further tasks.

Output:

print(create_dictionary())

# Output: {'name': 'John', 'age': 25, 'city': 'New York'}

Conclusion:

This task helped me understand how to define and return a dictionary in . I

learned how to work with dictionaries and how to store and retrieve data
efficiently.

Lab Report

Exercise Number: [17]

Date: 5/12/2024

Course Title: 24Z110 Programming Lab

Student Name: SUGANTH V

Roll Number: 24Z368

Objective:

The objective of this lab is to write a program that prints twin primes less
than 1000. Twin primes are pairs of prime numbers that have a difference
of 2.

Experiment:

1. Problem Statement:

Write a program to print twin primes less than 1000. Twin primes are
pairs of consecutive prime numbers with a difference of 2.

2. Algorithm/Logic:

Define a function is_prime() that checks if a number is prime.

Iterate through numbers from 2 to 1000.

Check each number and its next consecutive number to see if both are
prime and their difference is 2.

Print each twin prime pair.

3. Code:

def is_prime(num):

if num < 2:

return False

for i in range(2, int(num ** 0.5) + 1):

if num % i == 0:

return False

return True

def twin_primes():
 for i in range(2, 1000):

if is_prime(i) and is_prime(i + 2):

print(f"({i}, {i + 2})")

4. Execution Process:

I tested the function by printing twin primes for numbers between 2 and
1000.

I used the is_prime() function to check for prime numbers and verified if
the difference between two consecutive primes is exactly 2.

Observations:

The program successfully identified twin prime pairs.

It efficiently printed all twin primes less than 1000.

Output:

twin_primes()

# Output: (3, 5), (5, 7), (11, 13), (17, 19), ...

Conclusion:

This task helped me understand how to identify prime numbers and check
for twin primes. I used a combination of loops and conditions to find twin
primes less than 1000.

Lab Report

Exercise Number: [18]

Date: 5/12/2024

Course Title: 24Z110 Programming Lab

Student Name: SUGANTH V

Roll Number: 24Z368

Objective:

The objective of this lab is to calculate the sum of the cubes of individual
digits of a number and use it to check for Armstrong numbers.

Experiment:

1. Problem Statement:

Write a function cubesum() that accepts an integer and returns the sum of
the cubes of its digits. Then, use this function to create PrintArmstrong()
and isArmstrong() to check if a number is Armstrong.

2. Algorithm/Logic:

Define the cubesum() function that calculates the sum of the cubes of
digits of a number.

Define the isArmstrong() function that checks if a number is an Armstrong

number.

Define PrintArmstrong() to print Armstrong numbers up to a certain limit.

3. Code:

def cubesum(num):

return sum(int(digit) ** 3 for digit in str(num))

def isArmstrong(num):

return num == cubesum(num)

def PrintArmstrong(limit):

for num in range(limit):

if isArmstrong(num):

print(num)
4. Execution Process:

I used the cubesum() function to calculate the sum of cubes of digits for
any given number.

I tested isArmstrong() with numbers like 153 and 370 to verify if they are
Armstrong numbers.

The function PrintArmstrong() was used to print all Armstrong numbers

below a limit.

Observations:

The program correctly identified Armstrong numbers up to a specified

limit.

It successfully calculated the sum of cubes of digits.

Output:

PrintArmstrong(1000)

# Output: 153, 370, 371, 407

Conclusion:

This task helped me understand Armstrong numbers and how to calculate

the sum of cubes of digits. I learned to use helper functions like cubesum()
and isArmstrong() to solve this problem.

Lab Report

Exercise Number: [19]

Date: 5/12/2024

Course Title: 24Z110 Programming Lab

Student Name: SUGANTH V

Roll Number: 24Z368

Objective:

The objective of this lab is to find the sum of proper divisors of a number.

Experiment:

1. Problem Statement:

Write a function sumPdivisors() that finds the sum of the proper divisors of
a number. Proper divisors are divisors of a number excluding the number
itself.

2. Algorithm/Logic:

Define a function sumPdivisors() that takes an integer as input.

Find all divisors of the number and sum them, excluding the number itself.

Return the sum of proper divisors.

3. Code:

def sumPdivisors(num):

divisors_sum = 0

for i in range(1, num):

if num % i == 0:

divisors_sum += i

return divisors_sum

4. Execution Process:

I tested the function with a number like 36 to check if the sum of its
proper divisors is calculated correctly.

I verified that the function excluded the number itself when summing the
divisors.
Observations:

The function successfully calculated the sum of proper divisors for

different numbers.

It handled both small and large numbers.

Output:

print(sumPdivisors(36)) # Output: 55 (1 + 2 + 3 + 4 + 6 + 9 + 12 + 18)

Conclusion:

This task helped me practice finding divisors of a number and summ

Lab Report

Exercise Number: [20]

Date: 5/12/2024

Course Title: 24Z110 Programming Lab

Student Name: SUGANTH V

Roll Number: 24Z368

Objective:

The objective of this lab is to write a program that identifies amicable

numbers. Two numbers are called amicable if the sum of the proper
divisors of each number equals the other number.

Experiment:

1. Problem Statement:

Write a function that checks whether two numbers are amicable numbers.
Two numbers are amicable if the sum of the proper divisors of each
number equals the other number.

2. Algorithm/Logic:

Define a function sumPdivisors() to calculate the sum of proper divisors of

a number.

Define a function are_amicable() that checks if two numbers are amicable.

For two numbers a and b, calculate the sum of the proper divisors of a and
b. If the sum of divisors of a equals b and the sum of divisors of b equals
a, then they are amicable.

3. Code:

def sumPdivisors(num):

divisors_sum = 0

for i in range(1, num):

if num % i == 0:

divisors_sum += i

return divisors_sum

def are_amicable(num1, num2):

return sumPdivisors(num1) == num2 and sumPdivisors(num2) ==

num1
# Example: Checking if 220 and 284 are amicable numbers

print(are_amicable(220, 284)) # Output: True

4. Execution Process:

I implemented the sumPdivisors() function to calculate the sum of proper

divisors.

I defined the are_amicable() function to check if two numbers are

amicable.

I tested the program with the example of 220 and 284 to verify the result.

Observations:

The program successfully identified 220 and 284 as amicable numbers.

The logic works as expected for checking pairs of amicable numbers.

Output:

are_amicable(220, 284) # Output: True

Conclusion:

This task allowed me to explore amicable numbers and understand how to

check if two numbers are amicable. The solution used proper divisors to
calculate the sum and compare the numbers effectively.