NAME - S.

Abhisesha Kumaara
REG NO - RA2211026010487

21CSC203P - ADVANCED PROGRAMMING

PRACTICE WEEK - 11
PYTHON PROGRAM USING CONTROL
STRUCTURES AND ARRAYS
1. Implement a python program to find the first largest and second
largest numbers in an Array.
Note: should not use any built-in sorting functions or libraries.

def find_largest_and_second_largest(arr):

if len(arr) < 2:

return "The array should contain at least two elements."

first_largest = second_largest = float('-inf')

for num in arr:

if num > first_largest:

second_largest = first_largest

first_largest = num

elif num > second_largest and num != first_largest:

second_largest = num

if second_largest == float('-inf'):

return "There is no second largest element."

return f"The first largest number is {first_largest} and the second largest number is
{second_largest}"
arr = [12, 34, 56, 23, 67, 45, 90]

result = find_largest_and_second_largest(arr)

print(result)
OUTPUT :

1. Write a Python program to calculate the sum of even numbers and the
sum of odd numbers in an array.
def sum_even_and_odd_numbers(arr):

sum_even = 0

sum_odd = 0

for num in arr:

if num % 2 == 0:

sum_even += num

else:

sum_odd += num

return sum_even, sum_odd

arr = [1, 2, 3, 4, 5, 6, 7, 8]

sum_even, sum_odd = sum_even_and_odd_numbers(arr)

print(f"Sum of even numbers: {sum_even}")

print(f"Sum of odd numbers: {sum_odd}")

OUTPUT :

1. Write a python program to count the Occurrences of a Specific

Element in an Array.
def count_occurrences(arr, element):
 count = 0

for item in arr:

if item == element:

count += 1

return count

arr = [1, 2, 3, 4, 2, 5, 2]

element_to_count = 2

occurrences = count_occurrences(arr, element_to_count)

print(f"The element {element_to_count} appears {occurrences} times in the array.")

OUTPUT :

1. Write a Python program that takes a sentence as input and identifies

and prints all the palindromic words in the sentence. Use an array to
store the palindromic words.
def is_palindrome(word):

• Helper function to check if a word is a palindrome

return word == word[::-1]

def find_palindromic_words(sentence):

words = sentence.split()

palindromic_words = []

for word in words:

if is_palindrome(word):

palindromic_words.append(word)
 return palindromic_words

input_sentence = "madam is driving her civic racecar"

palindromic_words = find_palindromic_words(input_sentence)

if palindromic_words:

print("Palindromic words in the sentence:")

for word in palindromic_words:

print(word)

else:

print("No palindromic words found in the sentence.")

OUTPUT :

1. Write a Python program that takes a list of numbers and removes all
duplicates from the list, preserving the original order of elements.
def remove_duplicates(input_list):

unique_list = []

for item in input_list:

if item not in unique_list:

unique_list.append(item)

return unique_list

input_list = [1, 2, 2, 3, 4, 4, 5, 6, 6]

result_list = remove_duplicates(input_list)

print("Original list:", input_list)

print("List with duplicates removed:", result_list)

OUTPUT :
1. Write a Python program that performs matrix multiplication. Ask the
user to input two matrices as lists of lists (2D arrays) and then multiply
them if possible. Make sure to check if the matrices are compatible for
multiplication and handle errors gracefully.
def matrix_multiplication(matrix1, matrix2):

rows1 = len(matrix1)
cols1 = len(matrix1[0])

rows2 = len(matrix2)

cols2 = len(matrix2[0])

if cols1 != rows2:

print("Matrix multiplication is not possible. Number of columns in the first matrix

must match the number of rows in the second matrix.")
return None

result = [[0 for _ in range(cols2)] for _ in range(rows1)]

for i in range(rows1):

for j in range(cols2):

for k in range(cols1):

result[i][j] += matrix1[i][k] * matrix2[k][j]

return result

def input_matrix(prompt):

matrix = []

print(prompt)

while True:

row = input()
 if not row:

break

matrix.append([int(x) for x in row.split()])

return matrix

try:

matrix1 = input_matrix("Enter the first matrix (each row on a new line, elements
separated by space, and an empty line to finish):")

matrix2 = input_matrix("Enter the second matrix (each row on a new line,

elements separated by space, and an empty line to finish):")

result = matrix_multiplication(matrix1, matrix2)

if result:

print("Matrix multiplication result:")

for row in result:

print(' '.join(map(str, row)))

except ValueError:

print("Invalid input. Please enter valid integers in the matrices.")

except Exception as e:

print("An error occurred:", e)

OUTPUT :
1. Write a python program to print diamond number pattern using Nested
Loops.
def print_diamond_pattern(n):

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

spaces = " " * ((n - i) // 2)

print(spaces, end="")

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

print(j, end="")

for j in range(i - 1, 0, -1):

print(j, end="")

print()

for i in range(n - 2, 0, -2):

• Print leading spaces

spaces = " " * ((n - i) // 2)
print(spaces, end="") for j
in range(1, i + 1):
print(j, end="")

for j in range(i - 1, 0, -1):

print(j, end="")

print()

n=5

print_diamond_pattern(n)
OUTPUT :

1. Write a Python program that simulates a simple guessing game.

Generate a random number and have the user guess it. Provide hints
like "too high" or "too low" until they guess correctly.
import random

def guessing_game():

lower_limit = 1

upper_limit = 100

secret_number = random.randint(lower_limit, upper_limit)

attempts = 0

print(f"Welcome to the guessing game! I'm thinking of a number between

{lower_limit} and {upper_limit}.")
while True:

try:

user_guess = int(input("Guess the number: "))

attempts += 1

if user_guess < secret_number:

print("Too low! Try again.")

elif user_guess > secret_number:

print("Too high! Try again.")

 else:

print(f"Congratulations! You guessed the number {secret_number}

correctly in {attempts} attempts.")
break

except ValueError:

print("Invalid input. Please enter a valid number.")

if __name__ == "__main__":

guessing_game()

OUTPUT :

1. Write a Python program that checks the strength of a password

entered by a user. The program should assess the password based on
criteria like length, use of uppercase and lowercase letters, digits, and
special characters. Use control structures and arrays to provide a
detailed evaluation.

import string

def check_password_strength(password):

length_criteria = 8

uppercase_criteria = 1

lowercase_criteria = 1

digit_criteria = 1

special_character_criteria = 1

uppercase_count = 0

lowercase_count = 0

digit_count = 0

special_character_count = 0

special_characters = string.punctuation

if len(password) < length_criteria:

return "Weak password: Password should be at least 8 characters long."

for char in password:

if char.isupper():

uppercase_count += 1

elif char.islower():

lowercase_count += 1

elif char.isdigit():

digit_count += 1

elif char in special_characters:

special_character_count += 1

evaluation = []

if uppercase_count < uppercase_criteria:

 evaluation.append("Add more uppercase letters.")

if lowercase_count < lowercase_criteria:

evaluation.append("Add more lowercase letters.")

if digit_count < digit_criteria:

evaluation.append("Add more digits.")

if special_character_count < special_character_criteria:

evaluation.append("Add more special characters.")

if len(evaluation) == 0:

return "Strong password: Password meets all criteria."

else:

return " ".join(evaluation)

password = input("Enter a password: ")

strength_evaluation = check_password_strength(password)

print(strength_evaluation)

OUTPUT :

1. Write a Python program that generates the Fibonacci sequence up to a

specified number of terms using a loop and stores it in an array.
def generate_fibonacci_sequence(n):

if n <= 0:

return []

fibonacci_sequence = [0, 1]
 while len(fibonacci_sequence) < n:

next_term = fibonacci_sequence[-1] + fibonacci_sequence[-2]

fibonacci_sequence.append(next_term)

return fibonacci_sequence

num_terms = int(input("Enter the number of Fibonacci terms to generate: "))

fib_sequence = generate_fibonacci_sequence(num_terms)

if fib_sequence:

print("Fibonacci sequence:")

print(fib_sequence)
else:

print("Please enter a positive number of terms to generate.")

OUTPUT :