J.

P Institute of Engineering and

Technology

Mini Project
Python-File organizer
session : 2022 – 2026
Date : 5th DEC 2023

Submitted by :

Name : Priti kumari sah

Course : B.tech , I.T
Semester : 3rd
Roll : 2102820130014

Submitted to : Shikha Ma’am

Signature :

Table of Contents
1. Print number of command line arguments...................3

2. Matrix multiplication...................................................4

3. Find GCD of two numbers..........................................6

4.Find the number of most frequent word in a file..........7

5. Find square root of a number by newton’s method.....8

6. Find power of a number...............................................9

7. Find maximum in a list..............................................10

8. Implement linear search.............................................11

9. Implement binary search............................................12

10. Implement selection sort..........................................13

11. Implement insertion sort..........................................14

12. Implement merge sort..............................................15

13. Find first n prime numbers......................................17

14. Simulate a bouncing ball in Pygame.......................18

1. Print number of command line arguments.

import sys
def main():

arguments = sys.argv[1:]

# Print the number of arguments

num_arguments = len(arguments)
print(f"Number of arguments: {num_arguments}")

if __name__ == "__main__":
main()

input : python3 file.py arg1 arg2 arg3

output : 3
2. Matrix multiplication

def matrix_multiplication(matrix1, matrix2):

result = []
rows1 = len(matrix1)
cols1 = len(matrix1[0])
rows2 = len(matrix2)
cols2 = len(matrix2[0])
if cols1 != rows2:
print("Matrix multiplication is not possible.")
return None

for i in range(rows1):
row = []
for j in range(cols2):
value = 0
for k in range(cols1):
value += matrix1[i][k] * matrix2[k][j]
row.append(value)
result.append(row)

return result

def print_matrix(matrix):
for row in matrix:
print(row)
matrix1 = [
[1, 2, 3],
[4, 5, 6],
[7, 8, 9]
]

matrix2 = [
[9, 8, 7],
[6, 5, 4],
[3, 2, 1]
]
result_matrix = matrix_multiplication(matrix1, matrix2)
if result_matrix:
print("Matrix 1:")
print_matrix(matrix1)
print("\nMatrix 2:")
print_matrix(matrix2)
print("\nResult Matrix:")
print_matrix(result_matrix)

output:
Matrix 1:
[1, 2, 3]
[4, 5, 6]
[7, 8, 9]

Matrix 2:
[9, 8, 7]
[6, 5, 4]
[3, 2, 1]
Result Matrix:
[30, 24, 18]
[84, 69, 54]
[138, 114, 90]

3. Find GCD of two numbers.

def gcd(a, b):

while b:
a, b = b, a % b
return a

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

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

result = gcd(num1, num2)

print(f"The GCD of {num1} and {num2} is {result}")

output:
Enter the first number: 48
Enter the second number: 18
The GCD of 48 and 18 is 6.
4.Find the number of most frequent word in a file.

import re
from collections import Counter

def most_frequent_word(filename):
with open(filename, 'r') as file:
text = file.read()

words = re.findall(r'\b\w+\b', text.lower()) # Extract

words and convert to lowercase
word_counts = Counter(words)

most_common_word, frequency =
word_counts.most_common(1)[0]
return most_common_word, frequency

filename = "your_text_file.txt" # Replace with the path to

your text file
most_common_word, frequency =
most_frequent_word(filename)
print(f"The most frequent word is '{most_common_word}'
with a frequency of {frequency}.")
output:
Enter the name of the text file: sample.txt
The most frequent word is 'the' with a frequency of 3.

5. Find square root of a number by newton’s method.

def newton_sqrt(number, iterations=10):

x = number # Initial guess

for _ in range(iterations):
x = (x + number / x) / 2

return x

# Input: The number for which you want to find the square
root
number = float(input("Enter a number: "))

# Input: Number of iterations for Newton's method

(optional)
iterations = int(input("Enter the number of iterations
(default is 10): ") or "10")

result = newton_sqrt(number, iterations)

print(f"The square root of {number} is approximately
{result:.6f}")
6. Find power of a number.

def iterative_power(base, exponent):

result = 1
for _ in range(exponent):
result *= base
return result

# Input: Base and exponent

base = float(input("Enter the base: "))
exponent = int(input("Enter the exponent: "))

result = iterative_power(base, exponent)

print(f"{base} raised to the power of {exponent}: {result}")

output:
Enter the base: 2
Enter the exponent: 5
2 raised to the power of 5 : 32
7. Find maximum in a list.

def find_maximum(numbers):
if not numbers:
return None

maximum = numbers[0]
for num in numbers:
if num > maximum:
maximum = num
return maximum

# Input: List of numbers

numbers = input("Enter a list of numbers separated by
spaces: ").split()
numbers = [float(num) for num in numbers] # Convert to
floats

maximum = find_maximum(numbers)

if maximum is not None:

print(f"The maximum value is: {maximum}")
else:
print("The list is empty, so there is no maximum value.")
input list :[1,5,2,5,2,10]

output : 10
8. Implement linear search.

def linear_search(arr, target):

for index, value in enumerate(arr):
if value == target:
return index
return -1 # Element not found

# Input: List of elements and the target element to search

elements = input("Enter a list of elements separated by
spaces: ").split()
target = input("Enter the element to search for: ")

# Perform linear search

index = linear_search(elements, target)

if index != -1:
print(f"Element '{target}' found at index {index}")
else:
print(f"Element '{target}' not found in the list")

output:
Enter a list of elements separated by spaces: 10 20 30 40 50
Enter the element to search for: 30
Element '30' found at index 2

9. Implement binary search.

def binary_search(arr, target):

left = 0
right = len(arr) - 1

while left <= right:

mid = left + (right - left) // 2
if arr[mid] == target:
return mid
elif arr[mid] < target:
left = mid + 1
else:
right = mid - 1
return -1 # Element not found
elements = input("Enter a sorted list of elements separated
by spaces: ").split()
elements = [int(element) for element in elements] #
Convert to integers
target = int(input("Enter the element to search for: "))

index = binary_search(elements, target)

if index != -1:
print(f"Element '{target}' found at index {index}")
else:
print(f"Element '{target}' not found in the list")

output : Enter a list : 10 20 30 40 50

Enter the element to search for: 30
Element '30' found at index 2
10. Implement selection sort.

def selection_sort(arr):
n = len(arr)

for i in range(n - 1):

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]

# Input: List of numbers

numbers = input("Enter a list of numbers separated by
spaces: ").split()
numbers = [float(num) for num in numbers] # Convert to
floats

selection_sort(numbers)
print("Sorted list:", numbers)
output:

Enter a list of numbers separated by spaces: 5 2 9 1 5

Sorted list: [1, 2, 5, 5, 9]

11. Implement insertion sort.

def insertion_sort(arr):
for i in range(1, len(arr)):
key = arr[i]
j=i-1
while j >= 0 and key < arr[j]:
arr[j + 1] = arr[j]
j -= 1
arr[j + 1] = key

# Input: List of numbers

numbers = input("Enter a list of numbers separated by
spaces: ").split()
numbers = [float(num) for num in numbers] # Convert to
floats

insertion_sort(numbers)
print("Sorted list:", numbers)
output:

Enter a list of numbers separated by spaces: 5 2 9 1 5

Sorted list: [1, 2, 5, 5, 9]

12. Implement merge sort.

def merge_sort(arr):
if len(arr) <= 1:
return arr

mid = len(arr) // 2
left_half = arr[:mid]
right_half = arr[mid:]

left_half = merge_sort(left_half)
right_half = merge_sort(right_half)

return merge(left_half, right_half)

def merge(left, right):

result = []
 left_index, right_index = 0, 0

while left_index < len(left) and right_index < len(right):

if left[left_index] < right[right_index]:
result.append(left[left_index])
left_index += 1
else:
result.append(right[right_index])
right_index += 1

result.extend(left[left_index:])
result.extend(right[right_index:])
return result

# Input: List of numbers

numbers = input("Enter a list of numbers separated by
spaces: ").split()
numbers = [float(num) for num in numbers] # Convert to
floats

sorted_numbers = merge_sort(numbers)
print("Sorted list:", sorted_numbers)

output:

Enter a list of numbers separated by spaces: 5 2 9 1 5

Sorted list: [1, 2, 5, 5, 9]
13. Find first n prime numbers.
def is_prime(num):
if num <= 1:
return False
if num <= 3:
return True
if num % 2 == 0 or num % 3 == 0:
return False
i=5
while i * i <= num:
if num % i == 0 or num % (i + 2) == 0:
return False
i += 6
return True
def generate_primes(n):
primes = []
num = 2
while len(primes) < n:
if is_prime(num):
primes.append(num)
num += 1
return primes
n = int(input("Enter the number of prime numbers to
generate: "))
prime_numbers = generate_primes(n)

output:
Enter the number of prime numbers to generate: 5
The first 5 prime numbers are: [2, 3, 5, 7, 11]
14. Simulate a bouncing ball in Pygame.

import pygame
import sys

# Initialize Pygame
pygame.init()

# Window dimensions
width = 800
height = 600

# Colors
white = (255, 255, 255)

# Ball properties
ball_radius = 20
ball_color = (0, 0, 255)
ball_speed = [5, 5] # Initial speed (x, y)

# Create the window

screen = pygame.display.set_mode((width, height))
pygame.display.set_caption("Bouncing Ball Simulation")
# Create the ball rect
ball_rect = pygame.Rect(width // 2 - ball_radius, height // 2
- ball_radius, ball_radius * 2, ball_radius * 2)

# Main loop
while True:
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
sys.exit()

# Move the ball

ball_rect.x += ball_speed[0]
ball_rect.y += ball_speed[1]

# Bounce when hitting walls

if ball_rect.left <= 0 or ball_rect.right >= width:
ball_speed[0] = -ball_speed[0]
if ball_rect.top <= 0 or ball_rect.bottom >= height:
ball_speed[1] = -ball_speed[1]

# Clear the screen

screen.fill(white)

# Draw the ball

pygame.draw.circle(screen, ball_color, ball_rect.center,
ball_radius)

# Update the display

pygame.display.flip()
# Control the frame rate
pygame.time.Clock().tick(60)