S.
No Programs Date Signature
1 COMPUTE THE GCD OF TWO
NUMBERS
2 FIND THE SQUARE ROOT OF A
NUMBER (NEWTON‘S METHOD)
3 EXPONENTIATION (POWER OF
A NUMBER)
4 FIND THE MAXIMUM OF A LIST
OF NUMBERS
5 LINEAR SEARCH AND BINARY
SEARCH
6 SELECTION SORT
7 INSERTION SORT
8 MERGE SORT
9 FIRST N PRIME NUMBERS
10 MULTIPLY MATRICES
11 PROGRAMS THAT TAKE
COMMAND LINE ARGUMENTS
(WORD COUNT)
12 FIND THE MOST FREQUENT
WORDS IN A TEXT READ FROM
A FILE.
13 SIMULATE ELLIPTICAL ORBITS
IN PYGAME
14 SIMULATE BOUNCING BALL
USING PYGAME
PROGRAM-1: COMPUTE THE GCD OF TWO
NUMBERS
def gcd(a, b):
# Base case: if both numbers are the same, that is the GCD
if a == b:
return a
# If a > b, subtract b from a
elif a > b:
return gcd(a - b, b)
# If b > a, subtract a from b
else:
return gcd(a, b - a)
x = int(input(“Enter a number:”))
y = int(input(“Enter a number:”))
print("GCD of", x, "and", y, "is:", gcd(x, y))
PROGRAM-2: FIND THE SQUARE ROOT OF A
NUMBER (NEWTON ‘S METHOD)
def sqrt_newton(N, tolerance=1e-10, max_iter=100):
# Starting guess, we can use N itself or N/2
x = N / 2.0
# Iterate using Newton's method
for _ in range(max_iter):
# Apply the Newton's method formula
x_new = 0.5 * (x + N / x)
# If the difference between new and old guess is small enough, stop
if abs(x_new - x) < tolerance:
return x_new
# Update guess for next iteration
x = x_new
return x # Return the approximated result after max iterations
number = 25
result = sqrt_newton(number)
print(f"The square root of {number} is approximately {result}")
PROGRAM-3: EXPONENTIATION (POWER OF A
NUMBER)
def power(base, exp):
# Base case: exp = 0, any number to the power of 0 is 1
if exp == 0:
return 1
# If exponent is negative, calculate power of positive exponent and
take reciprocal
elif exp < 0:
return 1 / power(base, -exp)
# If exponent is even, use exponentiation by squaring
elif exp % 2 == 0:
half = power(base, exp // 2)
return half * half
# If exponent is odd
else:
return base * power(base, exp - 1)
base = 2
exponent = 10
result = power(base, exponent)
print(f"{base} raised to the power of {exponent} is {result}")
PROGRAM-4: FIND THE MAXIMUM OF A LIST OF
NUMBERS
# Function to find the maximum in a list using a loop
def find_max(numbers):
max_value = numbers[0]
for num in numbers:
if num > max_value:
max_value = num
return max_value
# Take user input for a list of numbers
user_input = input("Enter a list of numbers separated by spaces: ")
# Convert the input string into a list of integers
numbers = [int(num) for num in user_input.split()]
# Find the maximum value in the list
max_value = find_max(numbers)
# Print the result
print(f"The maximum value in the list is: {max_value}")
PROGRAM-5: LINEAR SEARCH & BINARY SEARCH
def linear_search(arr, target):
# Iterate through each element in the list
for i in range(len(arr)):
if arr[i] == target:
return i # Target found, return the index
return -1 # Target not found
numbers = [5, 3, 9, 1, 6, 7, 2]
target = int(input("Enter a number to search: "))
result = linear_search(numbers, target)
if result != -1:
print(f"Element {target} found at index {result}.")
else:
print(f"Element {target} not found.")
def binary_search(arr, target):
low = 0
high = len(arr) - 1
while low <= high:
mid = (low + high) // 2 # Find the middle index
if arr[mid] == target:
return mid # Target found
elif arr[mid] < target:
low = mid + 1 # Search the right half
else:
high = mid - 1 # Search the left half
return -1 # Target not found
numbers = [1, 3, 5, 6, 7, 9] # Sorted list
target = int(input("Enter a number to search: "))
result = binary_search(numbers, target)
if result != -1:
print(f"Element {target} found at index {result}.")
else:
print(f"Element {target} not found.")
PROGRAM-6: SELECTION SORT
def selection_sort(arr):
n = len(arr)
# Iterate over each element of the list
for i in range(n):
# Find the smallest element in the remaining unsorted portion of the
list
min_index = i
for j in range(i + 1, n):
if arr[j] < arr[min_index]:
min_index = j
# Swap the found minimum element with the first element of the
unsorted portion
arr[i], arr[min_index] = arr[min_index], arr[i]
numbers = [64, 25, 12, 22, 11]
print("Original list:", numbers)
selection_sort(numbers)
print("Sorted list:", numbers)
PROGRAM-7: INSERTION SORT
def insertion_sort(arr):
# Start from the second element (index 1)
for i in range(1, len(arr)):
key = arr[i] # The element to be inserted
j = i - 1 # The index of the previous element
# Move elements of arr[0..i-1] that are greater than key
# to one position ahead of their current position
while j >= 0 and arr[j] > key:
arr[j + 1] = arr[j]
j -= 1
# Insert the key at the correct position
arr[j + 1] = key
numbers = [64, 25, 12, 22, 11]
print("Original list:", numbers)
insertion_sort(numbers)
print("Sorted list:", numbers)
PROGRAM-8: MERGE SORT
def merge_sort(arr):
# Base case: If the array has one or zero elements, it's already sorted
if len(arr) <= 1:
return arr
# Step 1: Divide the array into two halves
mid = len(arr) // 2
left_half = arr[:mid]
right_half = arr[mid:]
# Step 2: Recursively sort each half
left_half = merge_sort(left_half)
right_half = merge_sort(right_half)
# Step 3: Merge the two sorted halves
return merge(left_half, right_half)
def merge(left, right):
sorted_array = []
i=j=0
# Merge the two arrays until one of them is exhausted
while i < len(left) and j < len(right):
if left[i] < right[j]:
sorted_array.append(left[i])
i += 1
else:
sorted_array.append(right[j])
j += 1
# If there are any remaining elements in left, add them
while i < len(left):
sorted_array.append(left[i])
i += 1
# If there are any remaining elements in right, add them
while j < len(right):
sorted_array.append(right[j])
j += 1
return sorted_array
arr = [38, 27, 43, 3, 9, 82, 10]
sorted_arr = merge_sort(arr)
print("Sorted array:", sorted_arr)
PROGRAM-9: FIRST N PRIME NUMBERS
import math
def is_prime(num):
"""Check if a number is prime."""
if num <= 1:
return False
for i in range(2, int(math.sqrt(num)) + 1):
if num % i == 0:
return False
return True
def first_n_primes(n):
"""Return the first N prime numbers."""
primes = []
num = 2 # Start checking from the first prime number
while len(primes) < n:
if is_prime(num):
primes.append(num)
num += 1
return primes
n = int(input("ENTER N:"))
primes = first_n_primes(n)
print(f"The first {n} prime numbers are: {primes}")
PROGRAM-10: MULTIPLY MATRICES
def multiply_matrices(A, B):
# Get dimensions of A and B
rows_A = len(A)
cols_A = len(A[0])
rows_B = len(B)
cols_B = len(B[0])
# Check if multiplication is possible (columns of A == rows of B)
if cols_A != rows_B:
raise ValueError("Number of columns of A must be equal to
number of rows of B.")
# Initialize result matrix C with zeros
C = [[0] * cols_B for _ in range(rows_A)]
# Perform matrix multiplication
for i in range(rows_A):
for j in range(cols_B):
for k in range(cols_A): # or range(rows_B), since cols_A ==
rows_B
C[i][j] += A[i][k] * B[k][j]
return C
A=[
[1, 2],
[3, 4]
]
B=[
[5, 6],
[7, 8]
]
result = multiply_matrices(A, B)
# Printing the result
for row in result:
print(row)
PROGRAM-11: PROGRAMS THAT TAKE COMMAND
LINE ARGUMENTS (WORD COUNT)
import sys
def count_words_in_file(filename):
"""Count the number of words in a file."""
try:
with open(filename, 'r') as file:
# Read the file content and split it into words
text = file.read()
words = text.split() # Default split by whitespace (spaces,
newlines, etc.)
return len(words)
except FileNotFoundError:
print(f"Error: The file '{filename}' was not found.")
return 0
def main():
if len(sys.argv) != 2:
print("Usage: python word_count.py <filename>")
sys.exit(1) # Exit the program if incorrect number of arguments
filename = sys.argv[1] # The first command-line argument is the file
name
word_count = count_words_in_file(filename)
print(f"The file '{filename}' contains {word_count} words.")
if __name__ == "__main__":
main()
PROGRAM-12: FIND THE MOST FREQUENT WORDS
IN A TEXT READ FROM A FILE.
import sys
from collections import Counter
import re
def count_most_frequent_words(filename, top_n=10):
"""Count the most frequent words in the given file."""
try:
with open(filename, 'r') as file:
# Read the entire file content
text = file.read()
# Convert the text to lowercase to make the counting case-
insensitive
text = text.lower()
# Use regular expression to extract words (remove punctuation)
words = re.findall(r'\b\w+\b', text)
# Count word frequencies using Counter
word_counts = Counter(words)
# Get the most common 'top_n' words
most_common_words = word_counts.most_common(top_n)
return most_common_words
except FileNotFoundError:
print(f"Error: The file '{filename}' was not found.")
return []
def main():
if len(sys.argv) != 2:
print("Usage: python most_frequent_words.py <filename>")
sys.exit(1)
filename = sys.argv[1] # The first command-line argument is the file
name
most_common_words = count_most_frequent_words(filename)
if most_common_words:
print("Most frequent words in the file:")
for word, count in most_common_words:
print(f"{word}: {count}")
if __name__ == "__main__":
main()
PROGRAM-13: SIMULATE ELLIPTICAL ORBITS IN
PYGAME
import pygame
import math
# initialize the pygame
pygame.init()
# define width of screen
width = 1000
# define height of screen
height = 600
screen_res = (width, height)
pygame.display.set_caption("GFG Elliptical orbit")
screen = pygame.display.set_mode(screen_res)
# define colors in RGB format
# These colors will be used in our game
red = (255, 0, 0)
green = (0, 255, 0)
blue = (0, 0, 255)
cyan = (0, 255, 255)
# centers of screen
X_center = width//2
Y_center = height//2
# radius of ellipse
# X_ellipse is major radius of ellipsis
X_ellipse = 400
# Y_ellipse is minor radius of ellipsis
Y_ellipse = 225
# pygame.time.Clock() will be used further
# in the game loop to control
# the speed of the planet.
clock = pygame.time.Clock()
while True:
for degree in range(0, 360, 1):
# event loop
for event in pygame.event.get():
if event.type == pygame.QUIT:
exit()
# fill black color on screen
screen.fill([0, 0, 0])
# We will find coordinates of 2 planet
# that will rotate in same ellipse
# calculate coordinates of planet 1
# x_planet is x coordinate
x_planet_1 = int(math.cos(degree * 2 * math.pi/360)
* X_ellipse) + X_center
# y_planet is y coordinate
y_planet_1 = int(math.sin(degree * 2 * math.pi/360)
* Y_ellipse) + Y_center
# calculate coordinates of planet 2
# As we want our planets to be opposite to
# each other so we will maintain a difference
# of 180 degrees between then
degree_2 = degree+180
# degree will be always between 0 and 360
if degree > 180:
degree_2 = degree-180
# x_planet is x coordinate
x_planet_2 = int(math.cos(degree_2 * 2 * math.pi/360)
* X_ellipse) + X_center
# y_planet is y coordinate
y_planet_2 = int(math.sin(degree_2 * 2 * math.pi/360)
* Y_ellipse) + Y_center
# draw circle in center of screen
pygame.draw.circle(surface=screen, color=red, center=[
X_center, Y_center], radius=60)
# draw ellipse
# Coordinate of left topmost point is (100,75)
# width of ellipse = 2*(major radius of ellipse)
# height of ellipse = 2*(minor radius of ellipse)
pygame.draw.ellipse(surface=screen, color=green,
rect=[100, 75, 800, 450],
width=1)
# draw both planets
# x_planet_1, y_planet_1, x_planet_2
# and y_planet_2 are calculated above
pygame.draw.circle(surface=screen, color=blue, center=[
x_planet_1, y_planet_1], radius=40)
pygame.draw.circle(surface=screen, color=cyan, center=[
x_planet_2, y_planet_2], radius=40)
# Frame Per Second /Refresh Rate
clock.tick(5)
# update screen
pygame.display.flip()
PROGRAM-14: SIM ULATE BOUNCING BALL USING
PYGAME
import pygame
# initialize pygame
pygame.init()
# define width of screen
width = 1000
# define height of screen
height = 600
screen_res = (width, height)
pygame.display.set_caption("GFG Bouncing game")
screen = pygame.display.set_mode(screen_res)
# define colors
red = (255, 0, 0)
black = (0, 0, 0)
# define ball
ball_obj = pygame.draw.circle(
surface=screen, color=red, center=[100, 100], radius=40)
# define speed of ball
# speed = [X direction speed, Y direction speed]
speed = [1, 1]
# game loop
while True:
# event loop
for event in pygame.event.get():
# check if a user wants to exit the game or not
if event.type == pygame.QUIT:
exit()
# fill black color on screen
screen.fill(black)
# move the ball
# Let center of the ball is (100,100) and the speed is (1,1)
ball_obj = ball_obj.move(speed)
# Now center of the ball is (101,101)
# In this way our wall will move
# if ball goes out of screen then change direction of movement
if ball_obj.left <= 0 or ball_obj.right >= width:
speed[0] = -speed[0]
if ball_obj.top <= 0 or ball_obj.bottom >= height:
speed[1] = -speed[1]
# draw ball at new centers that are obtained after moving ball_obj
pygame.draw.circle(surface=screen, color=red,
center=ball_obj.center, radius=40)
# update screen
pygame.display.flip()
