Non-CS Module -1 Lab -1-
*Time conversion*
import sys
def doSomething(inval):
if inval[-2:]=="AM":
outval=inval[:-2]
check=int(inval[0:2])
if check ==12:
outval="00"+outval[2:]
else:
outval=inval[:-2]
check=int(inval[0:2])
if check<12:
check+=12
outval=str(check)+outval[2:]
return outval
inputVal = str(input())
outputVal = doSomething(inputVal)
print (outputVal)
*Reverse a string*
def is_alphabet(c):
return c.isalpha()
def reverse_alphabets_with_case_preservation(input_str):
alphabets = [char for char in input_str if is_alphabet(char)]
reversed_alphabets = ''.join(reversed(alphabets))
result = []
j = 0
for char in input_str:
if is_alphabet(char):
result.append(reversed_alphabets[j])
j += 1
else:
result.append(char)
return ''.join(result)
def main():
input_str = input()
reversed_str = reverse_alphabets_with_case_preservation(input_str)
print(reversed_str)
if __name__ == "__main__":
main()
Non-CS Module-1 Lab-2
*Sort colors*
def sortColors(nums):
counts={0:0,1:0,2:0}
for color in nums:
counts[color]+=1
index=0
for color in [0,1,2]:
count=counts[color]
for _ in range(count):
nums[index]=color
index+=1
nums=list(map(int,input().split()))
sortColors(nums)
sorted_colors=' '.join(map(str,nums))
print(sorted_colors)
*Restore IP address:*
def is_valid(ip):
# Splitting by "."
ip = ip.split(".")
# Checking for the corner cases
for i in ip:
if (len(i) > 3 or int(i) < 0 or int(i) > 255):
return False
if len(i) > 1 and int(i) == 0:
return False
if (len(i) > 1 and int(i) != 0 and i[0] == '0'):
return False
return True
# Function converts string to IP address
def convert(s):
sz = len(s)
# Check for string size
if sz > 12:
return []
snew = s
l = []
# Generating different combinations.
for i in range(1, sz - 2):
for j in range(i + 1, sz - 1):
for k in range(j + 1, sz):
snew = snew[:k] + "." + snew[k:]
snew = snew[:j] + "." + snew[j:]
snew = snew[:i] + "." + snew[i:]
# Check for the validity of combination
if is_valid(snew):
l.append(snew)
snew = s
return l
inputVal = input()
outputVal = convert(inputVal)
print (outputVal)
Non-CS Module-2 Lab-1
*Generate Brackets:*
import sys
def doSomething(str,n):
if n>0:
printpara(str,0,n,0,0)
return
def printpara(str,pos,n,open,close):
if(close==n):
for i in str:
print(i,end = " ")
print()
return
else:
if(open>close):
str[pos] = ')'
printpara(str,pos+1,n,open,close+1)
if(open<n):
str[pos] = '('
printpara(str,pos+1,n,open+1,close)
inputVal = int(input())
str = [""]*2*inputVal
doSomething(str,inputVal)
*INTEGER TO ROMAN*
def R_to_I(inval):
dict1 = {'I': 1, 'V': 5, 'X': 10, 'L': 50, 'C': 100, 'D': 500, 'M': 1000}
count = 0
i = 0
while i < len(inval):
# Check if the current character and the next character form a valid Roman
numeral
if i + 1 < len(inval) and inval[i:i+2] in dict1:
count += dict1[inval[i:i+2]]
i += 2
else:
count += dict1[inval[i]]
i += 1
return count
inputVal = input("Enter a Roman numeral:\n ")
result = R_to_I(inputVal)
print(f"The integer representation of {inputVal} is: {result}")
outputVal = R_to_I(inputVal)
print (outputVal)
Non CS Module -2 Lab-2
*Closest Triples:*
def threeSumClosest(nums, target):
nums.sort()
closest_sum = float('inf')
for i in range(len(nums) - 2):
left, right = i + 1, len(nums) - 1
while left < right:
curr_sum = nums[i] + nums[left] + nums[right]
if abs(curr_sum - target) < abs(closest_sum - target):
closest_sum = curr_sum
if curr_sum < target:
left += 1
elif curr_sum > target:
right -= 1
else:
return curr_sum
return closest_sum
numbers = list(map(int, input().split()))
target = int(input())
result = threeSumClosest(numbers, target)
print(result)
Combination Sum:
def doSomething(arr, target_sum):
outval = []
temp = []
arr = sorted(list(set(arr)))
num(outval, arr, temp, target_sum, 0)
return outval
def num(outval, arr, temp, target_sum, index):
if target_sum == 0:
outval.append(list(temp))
return
for i in range(index, len(arr)):
if target_sum - arr[i] >= 0:
temp.append(arr[i])
num(outval, arr, temp, target_sum - arr[i], i)
temp.remove(arr[i])
# Take user input for the array
arr_input = input()
arr = [int(x) for x in arr_input.split(" ")]
# Take user input for the target sum
target_sum = int(input())
# Call the function and print the result
outputVal = doSomething(arr, target_sum)
# Format the output
output_str = '\n'.join([' '.join(map(str, sublist)) for sublist in outputVal])
print(output_str)
Non-CS Module-3 Lab-1 Dipesh
*Word Game:*
def exist(board, word):
def dfs(i, j, k):
if not (0<= i<len(board)) or not(0<=j<len(board[0])) or board[i][j]!
=word[k]:
return False
if k==len(word)-1:
return True
tmp, board[i][j]= board[i][j],'/'
found=dfs(i+1,j,k+1) or dfs(i-1,j,k+1) or dfs(i,j+1,k+1) or dfs(i,j-1,k+1)
board[i][j]=tmp
return found
for i in range(len(board)):
for j in range(len(board[0])):
if dfs(i, j, 0):
return True
return False
rows= int(input())
columns= int(input())
word=input()
Input=input()
rows_input = Input.strip().split(" ")
if columns == 0:
coumns =len(rows_input)
board = [list(row) for row in rows_input]
output= exist(board,word)
if output==True:
print('Yes')
else:
print('No')
*Jump Game:*
def can_jump(nums):
n = len(nums)
max_reach = 0
for i in range(n):
if i > max_reach:
# If the current index is not reachable, return False
return False
max_reach = max(max_reach, i + nums[i])
if max_reach >= n - 1:
# If the maximum reachable index is greater than or equal to the last
index, return True
return True
return False
# Take user input for the array
nums = input()
nums = [int(x) for x in nums.split(" ")]
# Call the function and print the result
result = can_jump(nums)
if result==True:
print('true')
else:
print('false')
Non CS Module-3 Lab-2 ABHI
*Longest Substring Containing Vowels in Even Counts*
def longest_substring_with_even_vowels(s):
vowels = {'a', 'e', 'i', 'o', 'u'}
count = {vowel: 0 for vowel in vowels}
count_tuple = tuple(count.values())
seen = {count_tuple: -1}
max_length = 0
for i, char in enumerate(s):
if char in vowels:
count[char] += 1
count_tuple = tuple(count[vowel] % 2 for vowel in vowels)
if count_tuple in seen:
max_length = max(max_length, i - seen[count_tuple])
else:
seen[count_tuple] = i
return max_length
input_string = input()
result = longest_substring_with_even_vowels(input_string)
print(result)
Mini Max
from itertools import combinations
def find_min_max_sums(numbers):
# Ensure the input list has at least 6 elements
if len(numbers) < 6:
print("Error: Input list must have at least 6 elements.")
return
# Find all combinations of 4 numbers
all_sums = [sum(combination) for combination in combinations(numbers, 4)]
# Find the minimum and maximum sums
min_sum = min(all_sums)
max_sum = max(all_sums)
print(f"{min_sum} {max_sum}")
input_string = input()
numbers = list(map(int, input_string.split()))
find_min_max_sums(numbers)
Non-CS Module-4 Lab-1 Gaya3
*Counting Sort 1*
def frequency_count(arr):
# Find the minimum and maximum elements in the array
min_element = min(arr)
max_element = max(arr)
# Iterate through the range of elements and count frequencies
for element in range(0, max_element + 1):
frequency = arr.count(element)
print(frequency, end=" ")
no_of_inputs = int(input()) # Convert to integer
input_str = input()
input_arr = list(map(int, input_str.split()))
frequency_count(input_arr)
*000G Cipher PY*
def encrypt(word, key, operation, cipher):
# Check if the word is in capitals
if not word.isupper():
print("Word should be in capitals.")
return
# Check if the key is not a number
if not key.isdigit():
print("Enter valid key.")
return
key = int(key)
# Check if the operation is either addition or subtraction
if operation not in ['addition', 'subtraction']:
print("Invalid Operation.")
return
# Substitution cipher
encrypted_word = ''.join(cipher[char] if char in cipher else char for char in
word)
# Apply mathematical operation
if operation == 'addition':
encrypted_word = ''.join(chr((ord(char) + key - ord('A')) % 26 + ord('A'))
for char in encrypted_word)
elif operation == 'subtraction':
encrypted_word = ''.join(chr((ord(char) - key - ord('A')) % 26 + ord('A'))
for char in encrypted_word)
return encrypted_word
cipher =
{'A':'Z','B':'Y','C':'X','D':'W','E':'V','F':'U','G':'T','H':'S','I':'R','J':'Q','K
':'P','L':'O','M':'N','N':'M','O':'L','P':'K','Q':'J','R':'I','S':'H','T':'G','U':'
F','V':'E','W':'D','X':'C','Y':'B','Z':'A'}
key = input()
operation = input()
word = input()
encrypted_word = encrypt(word, key, operation, cipher)
print(encrypted_word)
Non-CS Module-4 Lab-2
*Tower breakers*
def tower_game_winner(n, m):
# If there is only one tower, Player 1 wins
if n == 1:
return 1
# If the height of any tower is 1, Player 1 wins
if m == 1:
return 1
# If the height of any tower is even, Player 2 wins
if m % 2 == 0:
return 2
# Otherwise, Player 1 wins
return 1
# Example usage:
n, m = map(int, input().split())
winner = tower_game_winner(n, m)
print( winner)
*Grid Challenge*
import sys
def grid_challenge(grid):
# Rearrange element in each row in ascending alphabetical order
sorted_rows = [''.join(sorted(row)) for row in grid]
#check if columns are in ascending alphabetical order
columns_sorted = all(''.join(col) == ''.join(sorted(col)) for col in
zip(*sorted_rows))
# Sort the columns of the grid
sorted_columns = [sorted(column) for column in zip(*grid)]
# Check if the columns are sorted in non-decreasing order
columns_sorted = all(all(sorted_column[i] <= sorted_column[i + 1] for i in
range(len(sorted_column) - 1)) for sorted_column in sorted_columns)
return "YES" if columns_sorted else "NO"
grid_example = input()
result = grid_challenge(grid_example)
print(result)
