Experimet – 5

Ques : Find the sum of all the primes below two million.

Ans : def sum_of_primes_below(limit):

sieve = [True] * limit

sieve[0] = sieve[1] = False

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

if sieve[i]:

for j in range(i*i, limit, i):

sieve[j] = False

return sum(i for i, is_prime in enumerate(sieve) if is_prime)

prime_sum = sum_of_primes_below(2000000)

print("Sum of all primes below 2 million:", prime_sum)

Output :

Sum of all primes below 2 million: 142913828922

Ques : By considering the terms in the Fibonacci sequence whose values do not exceed four
million, WAP to find the sum of the even-valued terms.

Ans : def sum_even_fibonacci(limit):

a, b = 1, 2

total = 0

while a <= limit:

if a % 2 == 0:

total += a

a, b = b, a + b

return total

even_fib_sum = sum_even_fibonacci(4000000)

print("Sum of even Fibonacci numbers below 4 million:", even_fib_sum)

Output :
Sum of even Fibonacci numbers below 4 million: 4613732
 EXPERIMENT -6

Ques : Write a program to count the numbers of characters in the string and store them in a
dictionary data structure

Ans: def count_characters(input_string):

char_count = {}

for char in input_string:

if char in char_count:

char_count[char] += 1

else:

char_count[char] = 1

return char_count

user_input = input("Enter a string: ")

result = count_characters(user_input)

print("Character frequency dictionary:")

print(result)

OUTPUT :

Enter a string: hello

Character frequency dictionary:

{'h': 1, 'e': 1, 'l': 2, 'o': 1}

Ques: Write a program to use split and join methods in the string and trace a birthday of a
person with a dictionary data structure

ANS :

birthdays = {

"Alice": "12/05/1995",

"Bob": "23/08/1992",

"Charlie": "10/01/2000"

full_name = input("Enter the full name (e.g., Alice Johnson): ")

name_parts = full_name.split()

first_name = name_parts[0]

if first_name in birthdays:

birthday = birthdays[first_name]

date_parts = birthday.split("/")

formatted_birthday = "-".join(date_parts)

print(f"{first_name}'s birthday is on {formatted_birthday}")

else:

print(f"Sorry, no birthday record found for {first_name}")

OUTPUT :

Enter the full name (e.g., Alice Johnson): Alice Johnson

Alice's birthday is on 12-05-1995

 EXPERIMENT – 7

Ques :Write a program to count frequency of characters in a given file. Can you use character
frequency to tell whether the given file is a Python program file, C program file or a text file?

ANS :
def count_char_frequency(filename):
freq = {}
try:
with open(filename, 'r', encoding='utf-8') as file:
content = file.read()
for char in content:
if char in freq:
freq[char] += 1
else:
freq[char] = 1
return freq
except FileNotFoundError:
print("File not found.")
return {}
def guess_file_type(freq_dict):
python_keywords = ['def', 'import', 'self', ':', '#']
c_keywords = ['#include', 'int', 'main', '{', '}', ';']
all_chars = ''.join([k * v for k, v in freq_dict.items()])
score = {'Python': 0, 'C': 0, 'Text': 0}
for word in python_keywords:
if word in all_chars:
score['Python'] += 1
for word in c_keywords:
if word in all_chars:
score['C'] += 1
if score['Python'] == 0 and score['C'] == 0:
score['Text'] += 1
return max(score, key=score.get)
file_path = input("Enter file path: ")
freq_result = count_char_frequency(file_path)
if freq_result:
print("\nCharacter Frequency:")
for char, count in sorted(freq_result.items()):
print(f"'{char}': {count}")
file_type = guess_file_type(freq_result)
print(f"\n🔍 Based on character frequency, this looks like a **{file_type}** file.")

OUTPUT :Enter file path: sample.py

Character Frequency:
' ': 100
'\n': 20
'#': 3
'd': 10
Based on character frequency, this looks like a **Python** file.
 EXPERIMENT 8

QUES: Write a program to print each line of a file in reverse order.

ANS : def print_lines_in_reverse(filename):
try:
with open(filename, 'r', encoding='utf-8') as file:
for line in file:
print(line.strip()[::-1]) # strip() to remove \n, [::-1] to reverse
except FileNotFoundError:
print("File not found.")

# Example usage
file_path = input("Enter the file path: ")
print("\nReversed lines:")
print_lines_in_reverse(file_path)

OUTPUT : Enter the file path: sample.txt

Reversed lines:
!dlroW olleH
gnimmargorP nohtyP evol I

QUES : Write a program to compute the number of characters, words and lines in a file.

ANS : def count_file_stats(filename):

try:
with open(filename, 'r', encoding='utf-8') as file:
lines = file.readlines()
line_count = len(lines)
word_count = 0
char_count = 0
for line in lines:
word_count += len(line.split())
char_count += len(line)
print(f"\nFile Statistics:")
print(f"Lines: {line_count}")
print(f"Words: {word_count}")
print(f"Characters (including spaces/newlines): {char_count}")]
except FileNotFoundError:
print("File not found.")
file_path = input("Enter the file path again for stats: ")
count_file_stats(file_path)

OUTPUT :

Enter the file path again for stats: sample.txt

File Statistics:
Lines: 2
Words: 5
Characters (including spaces/newlines): 35
 EXPERIMENT – 9
Ques : Write a function nearly equal to test whether two strings are nearly equal. Two strings a
and b are nearly equal when a can be generated by a single mutation on.

ANS : def nearly_equal(a, b):

len_a = len(a)

len_b = len(b)

if len_a == len_b:

diff = sum(1 for x, y in zip(a, b) if x != y)

return diff == 1

if abs(len_a - len_b) == 1:

if len_a > len_b:

a, b = b, a

i = j = diff = 0

while i < len(a) and j < len(b):

if a[i] != b[j]:

if diff:

return False

diff += 1

j += 1 # skip one character from longer string

else:

i += 1

j += 1

return True # one mismatch or end of loop

return False

OUTPUT : print(nearly_equal("cat", "cut"))

print(nearly_equal("cat", "cats"))

print(nearly_equal("cats", "cat"))

print(nearly_equal("cat", "dog"))

print(nearly_equal("cat", "cast"))

print(nearly_equal("cat", "cart"))
QUES : Write function to compute gcd, lcm of two numbers. Each function shouldn’t exceed
one line.

Ans :
from math import gcd

def lcm(a, b):

return a * b // gcd(a, b)

def main():

num1 = int(input("Enter the first number: "))

num2 = int(input("Enter the second number: "))

print(f"GCD of {num1} and {num2}: {gcd(num1, num2)}")

print(f"LCM of {num1} and {num2}: {lcm(num1, num2)}")

if __name__ == "__main__":
main()

Output :

Enter the first number: 12

Enter the second number: 16
GCD of 12 and 16: 4
LCM of 12 and 16: 48
 EXPERIMENT – 10

QUES : Write a program to implement Merge sort.

Ans :def merge_sort(arr):

if len(arr) > 1:

mid = len(arr) // 2

left_half = arr[:mid]

right_half = arr[mid:]

merge_sort(left_half)

merge_sort(right_half)

i=j=k=0

while i < len(left_half) and j < len(right_half):

if left_half[i] < right_half[j]:

arr[k] = left_half[i]

i += 1

else:

arr[k] = right_half[j]

j += 1

k += 1

while i < len(left_half):

arr[k] = left_half[i]

i += 1

k += 1

while j < len(right_half):

arr[k] = right_half[j]

j += 1

k += 1

def print_array(arr):

for elem in arr:

 print(elem, end=" ")

print()

if __name__ == "__main__":

arr = [38, 27, 43, 3, 9, 82, 10]

print("Original array:")

print_array(arr)

merge_sort(arr)

print("\nSorted array:")

print_array(arr)

OUTPUT :

Original array:

38 27 43 3 9 82 10

Sorted array:

3 9 10 27 38 43 82
Ques : Write a program to implement Selection sort, Insertion sort.

Ans : 1. Selection Sort

def selection_sort(arr):

n = len(arr)

for i in range(n):

min_index = i

for j in range(i + 1, n):

if arr[j] < arr[min_index]:

min_index = j

arr[i], arr[min_index] = arr[min_index], arr[i]

def print_array(arr):

for elem in arr:

print(elem, end=" ")

print()

if __name__ == "__main__":

arr = [64, 25, 12, 22, 11]

print("Original array:")

print_array(arr)

selection_sort(arr)

print("\nSorted array using Selection Sort:")

print_array(arr)

Output :

Original array:

64 25 12 22 11

Sorted array using Selection Sort:

11 12 22 25 64
2. INSERTION SORT

def insertion_sort(arr):

for i in range(1, len(arr)):

key = arr[i]

j=i-1

while j >= 0 and arr[j] > key:

arr[j + 1] = arr[j]

j -= 1

arr[j + 1] = key

def print_array(arr):

for elem in arr:

print(elem, end=" ")

print()

if __name__ == "__main__":

arr = [64, 34, 25, 12, 22, 11, 90]

print("Original array:")

print_array(arr)

insertion_sort(arr)

print("\nSorted array using Insertion Sort:")

print_array(arr)

OUTPUT :

Original array:

64 34 25 12 22 11 90

Sorted array using Insertion Sort:

11 12 22 25 34 64 90