1.
if __name__ == '__main__':
N = int(input().strip())
result = []
for _ in range(N):
command = input().strip().split()
if command[0] == "insert":
result.insert(int(command[1]), int(command[2]))
elif command[0] == "print":
print(result)
elif command[0] == "remove":
result.remove(int(command[1]))
elif command[0] == "append":
result.append(int(command[1]))
elif command[0] == "sort":
result.sort()
elif command[0] == "pop":
result.pop()
elif command[0] == "reverse":
result.reverse()
2.
def nth_term_of_series(n):
if n % 2 == 0:
# Even terms: 2^(n/2 - 1)
return 2 ** (n // 2 - 1)
else:
# Odd terms: n/2
return 3 ** (n // 2)
# Test the function
n = int(input("Enter the value of n: "))
result = nth_term_of_series(n)
print("The", n, "th term of the series is:", result)
3.
def custom_sort(lst):
# Split the list into two sublists: odd indices and even indices
odd_indices = lst[1::2]
even_indices = lst[::2]
# Sort the sublists separately
odd_indices.sort()
even_indices.sort(reverse=True)
# Combine the sorted sublists back into a single list
result = []
for i in range(len(lst)):
if i % 2 == 0:
result.append(even_indices.pop(0))
else:
result.append(odd_indices.pop(0))
return result
# Test the function
sample_input = [5, 3, 2, 1, 4, 6, 7, 9]
output = custom_sort(sample_input)
print("Expected Output:", output)
4.
def decrypt_message(encrypted_message):
decrypted_message = ""
for char in encrypted_message:
# Decrypt uppercase letters
if char.isupper():
decrypted_char = chr(((ord(char) - 65 - 3) % 26) + 65)
decrypted_message += decrypted_char
else:
decrypted_message += char # Keep non-alphabetic characters unchanged
return decrypted_message
# Test cases
input1 = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
input2 = "ATTACKATONCE"
print("Output 1:", decrypt_message(input1))
print("Output 2:", decrypt_message(input2))
5.
def power(base, exponent):
if exponent == 0:
return 1
elif exponent < 0:
return 1 / power(base, -exponent)
else:
return base * power(base, exponent - 1)
# Input base and exponent from the user
base = float(input("Enter the base: "))
exponent = int(input("Enter the exponent: "))
# Compute and print the result using the recursive function
result = power(base, exponent)
print("Result:", result)
6.
def celsius_to_fahrenheit(celsius):
return (celsius * 9/5) + 32
def celsius_to_kelvin(celsius):
return celsius + 273.15
def fahrenheit_to_celsius(fahrenheit):
return (fahrenheit - 32) * 5/9
def fahrenheit_to_kelvin(fahrenheit):
return (fahrenheit - 32) * 5/9 + 273.15
def kelvin_to_celsius(kelvin):
return kelvin - 273.15
def kelvin_to_fahrenheit(kelvin):
return (kelvin - 273.15) * 9/5 + 32
import temperature_converter
# Convert Celsius to Fahrenheit and Kelvin
celsius = 25
fahrenheit = temperature_converter.celsius_to_fahrenheit(celsius)
kelvin = temperature_converter.celsius_to_kelvin(celsius)
print(f"{celsius} Celsius is equal to {fahrenheit:.2f} Fahrenheit")
print(f"{celsius} Celsius is equal to {kelvin:.2f} Kelvin")
# Convert Fahrenheit to Celsius and Kelvin
fahrenheit = 77
celsius = temperature_converter.fahrenheit_to_celsius(fahrenheit)
kelvin = temperature_converter.fahrenheit_to_kelvin(fahrenheit)
print(f"{fahrenheit} Fahrenheit is equal to {celsius:.2f} Celsius")
print(f"{fahrenheit} Fahrenheit is equal to {kelvin:.2f} Kelvin")
# Convert Kelvin to Celsius and Fahrenheit
kelvin = 298
celsius = temperature_converter.kelvin_to_celsius(kelvin)
fahrenheit = temperature_converter.kelvin_to_fahrenheit(kelvin)
print(f"{kelvin} Kelvin is equal to {celsius:.2f} Celsius")
print(f"{kelvin} Kelvin is equal to {fahrenheit:.2f} Fahrenheit")
7.
# Initialize the answer key
answer_key = ['A', 'B', 'C', 'A']
def evaluate_responses(student_responses):
marks = 0
for i in range(len(answer_key)):
if student_responses[i] == answer_key[i]:
marks += 10
return marks
# Read and evaluate responses for each student
for i in range(1, 6):
print(f"Enter responses for Student {i}:")
student_responses = []
for j in range(4):
response = input(f"Response for question {j+1} (A/B/C): ").upper()
student_responses.append(response)
student_marks = evaluate_responses(student_responses)
print(f"Student {i} obtained {student_marks} marks.\n")
8.
class FlightBookingSystem:
def __init__(self):
self.flights = {}
def add_flight(self, flight_id, departure_city, arrival_city, departure_time, available_seats):
self.flights[flight_id] = {
'departure_city': departure_city,
'arrival_city': arrival_city,
'departure_time': departure_time,
'available_seats': available_seats
}
def view_available_flights(self):
print("Available Flights:")
for flight_id, details in self.flights.items():
print(f"Flight ID: {flight_id}, Departure City: {details['departure_city']}, Arrival City: {details['arrival_city']}, Depar
ble Seats: {details['available_seats']}")
def search_for_flights(self, criterion, value):
found_flights = []
for flight_id, details in self.flights.items():
if details[criterion] == value:
found_flights.append((flight_id, details))
return found_flights
def book_flight(self, flight_id, num_seats):
if flight_id in self.flights:
if self.flights[flight_id]['available_seats'] >= num_seats:
self.flights[flight_id]['available_seats'] -= num_seats
print(f"Successfully booked {num_seats} seats for flight {flight_id}")
else:
print("Not enough seats available for booking.")
else:
print("Invalid flight ID.")
def cancel_reservation(self, flight_id, num_seats):
if flight_id in self.flights:
self.flights[flight_id]['available_seats'] += num_seats
print(f"{num_seats} seats canceled for flight {flight_id}")
else:
print("Invalid flight ID.")
def view_booked_flights(self):
print("Booked Flights:")
for flight_id, details in self.flights.items():
booked_seats = details['available_seats']
available_seats = details['available_seats']
print(f"Flight ID: {flight_id}, Departure City: {details['departure_city']}, Arrival City: {details['arrival_city']}, Depar
Seats: {booked_seats}, Available Seats: {available_seats}")
# Example usage:
flight_system = FlightBookingSystem()
flight_system.add_flight(1, 'New York', 'London', '08:00', 200)
flight_system.add_flight(2, 'London', 'Paris', '10:00', 150)
flight_system.add_flight(3, 'Paris', 'Rome', '12:00', 180)
# View available flights
flight_system.view_available_flights()
# Search for flights
found_flights = flight_system.search_for_flights('departure_city', 'London')
print("Flights departing from London:")
for flight_id, details in found_flights:
print(f"Flight ID: {flight_id}, Departure City: {details['departure_city']}, Arrival City: {details['arrival_city']}, Departure
s: {details['available_seats']}")
# Book a flight
flight_system.book_flight(2, 2)
# Cancel reservation
flight_system.cancel_reservation(2, 1)
# View booked flights
flight_system.view_booked_flights()
9.
import math
num = 25
sqrt_num = math.sqrt(num)
print("Square root of", num, "is", sqrt_num)
import math
angle = math.pi / 6 # 30 degrees in radians
sin_value = math.sin(angle)
cos_value = math.cos(angle)
tan_value = math.tan(angle)
print("Sine of", angle, "is", sin_value)
print("Cosine of", angle, "is", cos_value)
print("Tangent of", angle, "is", tan_value)
import math
num = 4.7
ceil_value = math.ceil(num)
floor_value = math.floor(num)
print("Ceiling of", num, "is", ceil_value)
print("Floor of", num, "is", floor_value)
import random
random_num = random.randint(1, 100)
print("Random integer between 1 and 100:", random_num)
import random
colors = ['red', 'blue', 'green', 'yellow']
random_color = random.choice(colors)
print("Randomly chosen color:", random_color)
import random
numbers = [1, 2, 3, 4, 5]
random.shuffle(numbers)
print("Shuffled list:", numbers)
10.
import math
def distance_2d(x1, y1, x2, y2):
return math.sqrt((x2 - x1)**2 + (y2 - y1)**2)
def distance_3d(x1, y1, z1, x2, y2, z2):
return math.sqrt((x2 - x1)**2 + (y2 - y1)**2 + (z2 - z1)**2)
# Example usage:
print("Distance between two points in 2D space:", distance_2d(1, 2, 4, 6))
print("Distance between two points in 3D space:", distance_3d(1, 2, 3, 4, 5, 6))
import math
import matplotlib.pyplot as plt
def euler_method(f, x0, y0, h, n):
"""
Solves the ODE y' = f(x, y) using Euler's method.
f: Function representing the ODE, taking x and y as arguments.
x0, y0: Initial conditions.
h: Step size.
n: Number of steps.
"""
x_values = [x0]
y_values = [y0]
for i in range(n):
x = x_values[-1]
y = y_values[-1]
slope = f(x, y)
x_new = x + h
y_new = y + h * slope
x_values.append(x_new)
y_values.append(y_new)
return x_values, y_values
# Define the ODE representing a damped harmonic oscillator
def damped_harmonic_oscillator(x, y):
return -0.1 * y - math.sin(x)
# Initial conditions
x0 = 0
y0 = 1
# Step size and number of steps
h = 0.1
n = 100
# Solve the ODE using Euler's method
x_values, y_values = euler_method(damped_harmonic_oscillator, x0, y0, h, n)
# Plot the solution
plt.plot(x_values, y_values)
plt.xlabel('x')
plt.ylabel('y')
plt.title('Solution of Damped Harmonic Oscillator using Euler\'s Method')
plt.grid(True)
plt.show()
11.
import random
def roll_dice():
return random.randint(1, 6)
def simulate_rolling(num_trials):
results = {i: 0 for i in range(2, 13)} # Initialize dictionary to store results
for _ in range(num_trials):
die1 = roll_dice()
die2 = roll_dice()
total = die1 + die2
results[total] += 1
return results
def print_results(results):
print("Sum of Dice\tOccurrences")
print("-------------------------")
for total, count in results.items():
print(f"{total}\t\t{count}")
# Simulate rolling the dice 100 times
results = simulate_rolling(100)
# Print the results in tabular format
print_results(results)
import random
import string
def generate_password(length):
characters = string.ascii_letters + string.digits + string.punctuation
return ''.join(random.choice(characters) for _ in range(length))
# Example usage: Generate a random password of length 10
password = generate_password(10)
print("Randomly generated password:", password)
12.
import datetime
def find_nth_day(n):
# Get the current date
current_date = datetime.datetime.now().date()
print("Current date is", current_date.strftime("%d/%m/%Y"))
# Calculate Nth day before and after the current date
before_date = current_date - datetime.timedelta(days=n)
after_date = current_date + datetime.timedelta(days=n)
# Get the day names for before and after dates
before_day_name = before_date.strftime("%A")
after_day_name = after_date.strftime("%A")
# Print the results
print(f"{n} days before: {before_date.strftime('%d/%m/%Y')} - {before_day_name}")
print(f"After {n} days: {after_date.strftime('%d/%m/%Y')} - {after_day_name}")
# Sample input
N=5
find_nth_day(N)
13.
import datetime
def days_between_dates(date1, date2):
# Convert date strings to datetime objects
date1 = datetime.datetime.strptime(date1, "%Y-%m-%d").date()
date2 = datetime.datetime.strptime(date2, "%Y-%m-%d").date()
# Calculate the difference between the dates
delta = abs(date2 - date1)
# Return the number of days
return delta.days
# Example usage:
date_str1 = "2024-03-26"
date_str2 = "2024-04-05"
print("Number of days between", date_str1, "and", date_str2, "is:", days_between_dates(date_str1, date_str2))
