├── HelloWorld.py
├── Mod Divmod.py
├── Power - Mod Power.py
├── Input().py
├── Triangle Quest.py
├── Print Function.py
├── Set.add( ).py
├── Polar Coordinates.py
├── Integers Come In All Sizes.py
├── Tuples.py
├── Triangle Quest 2.py
├── Loops.py
├── sWAP cASE.py
├── Python Evaluation.py
├── Python_Division.py
├── itertools.product().py
├── Compress the String!.py
├── String Split and Join.py
├── What's Your Name.py
├── Maximize it!.py
├── Arithmetic Operators.py
├── Zipped!.py
├── Mutations.py
├── Set .intersection() Operation.py
├── Set .difference() Operation.py
├── String Validators.py
├── Introduction to Sets.py
├── Set .union() Operation.py
├── Find Angle MBC.py
├── Set .symmetric_difference() Operation.py
├── Designer Door Mat.py
├── Find the Runner-Up Score!.py
├── Text Wrap.py
├── Exceptions.py
├── Any or All.py
├── Python If-Else.py
├── itertools.permutations().py
├── Write a function.py
├── itertools.combinations_with_replacement().py
├── Set .discard(), .remove() & .pop().py
├── itertools.combinations().py
├── No Idea!.py
├── Merge the Tools!.py
├── List Comprehensions.py
├── Find a string.py
├── Check Subset.py
├── Finding the percentage.py
├── Words Score.py
├── Nested Lists.py
├── ginortS.py
├── Capitalize!.py
├── Lists.py
├── Default Arguments.py
├── Set Mutations.py
├── README.md
└── Alphabet Rangoli.py


/HelloWorld.py:
--------------------------------------------------------------------------------
1 | print("Hello, World!")
2 | 


--------------------------------------------------------------------------------
/Mod Divmod.py:
--------------------------------------------------------------------------------
1 | a = int(input(""))
2 | b = int(input(""))
3 | print('{}\n{}\n{}'.format((a//b),(a%b),divmod(a,b)))
4 | 


--------------------------------------------------------------------------------
/Power - Mod Power.py:
--------------------------------------------------------------------------------
1 | a = int(input(""))
2 | b = int(input(""))
3 | c = int(input(""))
4 | print(a**b)
5 | print(a**b%c)
6 | 


--------------------------------------------------------------------------------
/Input().py:
--------------------------------------------------------------------------------
1 | x , k = map(int , input("").split(' '))
2 | m = eval(input(""))
3 | print("{}".format('True' if k==m else 'False'))
4 | 


--------------------------------------------------------------------------------
/Triangle Quest.py:
--------------------------------------------------------------------------------
1 | for i in range(1,int(input())):
2 |     print([0,1,22,333,4444,55555,666666,7777777,88888888,999999999][i])
3 | 


--------------------------------------------------------------------------------
/Print Function.py:
--------------------------------------------------------------------------------
1 | if __name__ == '__main__':
2 |     n = int(input())
3 |     for i in range(1,n+1):
4 |         print(i,end='')
5 | 


--------------------------------------------------------------------------------
/Set.add( ).py:
--------------------------------------------------------------------------------
1 | n=int(input(""))
2 | s = set()
3 | for i in range(n):
4 |     m=input("")
5 |     s.add(m)
6 | 
7 | print(len(s))
8 | 


--------------------------------------------------------------------------------
/Polar Coordinates.py:
--------------------------------------------------------------------------------
1 | import cmath
2 | m=complex(input())
3 | print(abs(complex(m.real,m.imag)),'\n',cmath.phase(complex(m.real,m.imag)))
4 | 


--------------------------------------------------------------------------------
/Integers Come In All Sizes.py:
--------------------------------------------------------------------------------
1 | a = int(input(""))
2 | b = int(input(""))
3 | c = int(input(""))
4 | d = int(input(""))
5 | print(a**b+c**d)
6 | 


--------------------------------------------------------------------------------
/Tuples.py:
--------------------------------------------------------------------------------
1 | if __name__ == '__main__':
2 |     n = int(input())
3 |     integer_list = tuple(map(int, input().split()))
4 |     print(hash(integer_list))
5 | 


--------------------------------------------------------------------------------
/Triangle Quest 2.py:
--------------------------------------------------------------------------------
1 | for i in range(1,int(input())+1):
2 |     print([0,1,121,12321,1234321,123454321,12345654321,1234567654321,123456787654321,12345678987654321][i])
3 | 


--------------------------------------------------------------------------------
/Loops.py:
--------------------------------------------------------------------------------
1 | if __name__ == '__main__':
2 |     n = int(input())
3 |     for i in range(n):# 0<= i<n
4 |         result = i**2# we can do i*i also
5 |         print(result)
6 | 


--------------------------------------------------------------------------------
/sWAP cASE.py:
--------------------------------------------------------------------------------
1 | def swap_case(s):
2 |     return s.swapcase()
3 | 
4 | if __name__ == '__main__':
5 |     s = input()
6 |     result = swap_case(s)
7 |     print(result)
8 | 


--------------------------------------------------------------------------------
/Python Evaluation.py:
--------------------------------------------------------------------------------
 1 | inp = input("")
 2 | m=0
 3 | for i in (inp):
 4 |     if i=='(':
 5 |         s = inp[(m+1):-1]
 6 |         print(eval(s))
 7 |         break
 8 |     else:
 9 |         m+=1
10 | 


--------------------------------------------------------------------------------
/Python_Division.py:
--------------------------------------------------------------------------------
1 | if __name__ == '__main__':
2 |     a = int(input())
3 |     b = int(input())
4 |     int_result = int(a/b)
5 |     float_result = a/b
6 |     print(int_result)
7 |     print(float_result)
8 | 


--------------------------------------------------------------------------------
/itertools.product().py:
--------------------------------------------------------------------------------
1 | import itertools as it
2 | a = list(map(int , input("").split(' ')))
3 | b = list(map(int , input("").split(' ')))
4 | lst = list(x for x in it.product(a,b))
5 | for i in lst:
6 |     print(i, end = ' ' )
7 | 


--------------------------------------------------------------------------------
/Compress the String!.py:
--------------------------------------------------------------------------------
1 | from itertools import groupby as a
2 | s=input("")
3 | key=[k for k, g in a(s)]
4 | word= [list(g) for k, g in a(s)]
5 | for i in range(len(key)):
6 |     print("({}, {})".format(len(word[i]),key[i]),end=" ")
7 | 


--------------------------------------------------------------------------------
/String Split and Join.py:
--------------------------------------------------------------------------------
1 | def split_and_join(line):
2 |     return line.replace(' ','-')
3 |     # write your code here
4 | 
5 | if __name__ == '__main__':
6 |     line = input()
7 |     result = split_and_join(line)
8 |     print(result)
9 | 


--------------------------------------------------------------------------------
/What's Your Name.py:
--------------------------------------------------------------------------------
1 | def print_full_name(a, b):
2 |     print("Hello {} {}! You just delved into python.".format(a ,b))
3 | 
4 | if __name__ == '__main__':
5 |     first_name = input()
6 |     last_name = input()
7 |     print_full_name(first_name, last_name)
8 | 


--------------------------------------------------------------------------------
/Maximize it!.py:
--------------------------------------------------------------------------------
1 | from itertools import product
2 | K,M = map(int,input().split())
3 | nums = []
4 | for _ in range(K):
5 |     row = map(int,input().split()[1:])
6 |     nums.append(map(lambda x:x**2%M, row))
7 | print(max(map(lambda x: sum(x)%M, product(*nums))))
8 | 


--------------------------------------------------------------------------------
/Arithmetic Operators.py:
--------------------------------------------------------------------------------
 1 | if __name__ == '__main__':
 2 |     a = int(input())
 3 |     b = int(input())
 4 |     addition = a+b
 5 |     subtraction = a-b
 6 |     multiplication = a*b
 7 |     print(addition)
 8 |     print(subtraction)
 9 |     print(multiplication)
10 | 


--------------------------------------------------------------------------------
/Zipped!.py:
--------------------------------------------------------------------------------
 1 | No_Of_Students , X = map(int,input("").split(" "))
 2 | final_list=[]
 3 | for i in range(X):
 4 |     lst = [float(x) for x in input("").split(" ")]
 5 |     final_list.append(lst)
 6 | for i in zip(*final_list):
 7 |     print((sum(i)/len(i)))
 8 | 
 9 | 
10 | 


--------------------------------------------------------------------------------
/Mutations.py:
--------------------------------------------------------------------------------
1 | def mutate_string(string, position, character):
2 |     return string[:position]+character + string[(position+1):]
3 | 
4 | if __name__ == '__main__':
5 |     s = input()
6 |     i, c = input().split()
7 |     s_new = mutate_string(s, int(i), c)
8 |     print(s_new)
9 | 


--------------------------------------------------------------------------------
/Set .intersection() Operation.py:
--------------------------------------------------------------------------------
 1 | n1 = int(input(""))
 2 | ls1=set(map(int , input("").split(" ")))
 3 | n2 = int(input(""))
 4 | ls2=set(map(int , input("").split(" ")))
 5 | ma = set(ls1.intersection(ls2))
 6 | output=0
 7 | for i in ma:
 8 |   output+=1
 9 | print(output)
10 | 


--------------------------------------------------------------------------------
/Set .difference() Operation.py:
--------------------------------------------------------------------------------
 1 | m = int(input(""))
 2 | ma = set(map(int , input("").split(" ")))
 3 | m1 = int(input(""))
 4 | ma1 = set(map(int , input("").split(" ")))
 5 | Final_Set = ma.difference(ma1)
 6 | output = 0
 7 | for i in Final_Set:
 8 |     output+=1
 9 | print(output)
10 | 


--------------------------------------------------------------------------------
/String Validators.py:
--------------------------------------------------------------------------------
1 | if __name__ == '__main__':
2 |     s = input()
3 |     print(any(c.isalnum()  for c in s))
4 |     print(any(c.isalpha() for c in s))
5 |     print(any(c.isdigit() for c in s))
6 |     print(any(c.islower() for c in s))
7 |     print(any(c.isupper() for c in s))
8 | 
9 | 


--------------------------------------------------------------------------------
/Introduction to Sets.py:
--------------------------------------------------------------------------------
 1 | def average(array):
 2 |     return (sum(set(array))/len(set(array)))
 3 |     # your code goes here
 4 | 
 5 | if __name__ == '__main__':
 6 |     n = int(input())
 7 |     arr = list(map(int, input().split()))
 8 |     result = average(arr)
 9 |     print(result)
10 | 


--------------------------------------------------------------------------------
/Set .union() Operation.py:
--------------------------------------------------------------------------------
 1 | n1 = int(input(""))
 2 | ls1=set(map(int , input("").split(" ")))
 3 | n2 = int(input(""))
 4 | ls2=set(map(int , input("").split(" ")))
 5 | ma = set(ls1.union(ls2))
 6 | output =0
 7 | for i in ma:
 8 |     output+=1
 9 | 
10 | output = str(output)
11 | print(output)
12 | 


--------------------------------------------------------------------------------
/Find Angle MBC.py:
--------------------------------------------------------------------------------
1 | import math
2 | AB,BC=int(input()),int(input())
3 | hype=math.hypot(AB,BC)                      #to calculate hypotenuse
4 | res=round(math.degrees(math.acos(BC/hype))) #to calculate required angle 
5 | degree=chr(176)                                #for DEGREE symbol
6 | print(res,degree, sep='')
7 | 


--------------------------------------------------------------------------------
/Set .symmetric_difference() Operation.py:
--------------------------------------------------------------------------------
 1 | a0 = int(input(""))
 2 | s = set(filter(int , input("").split(' ')))
 3 | a1 = int(input(""))
 4 | Final_Set = set(filter(int , input("").split(' ')))
 5 | SetA = s.symmetric_difference(Final_Set)
 6 | output = 0
 7 | for i in SetA:
 8 |     output+=1
 9 | print(output)
10 | 


--------------------------------------------------------------------------------
/Designer Door Mat.py:
--------------------------------------------------------------------------------
 1 | n, k = map(int , input("").split(" "))
 2 | st ='.|.'
 3 | st1='-'
 4 | avg = int((n+1)/2)
 5 | for i in range(1,1+n):
 6 |     if avg==i:
 7 |         print("WELCOME".center(k,st1))
 8 |     elif i<avg:
 9 |         print((st*(2*i-1)).center(k,st1))
10 |     elif avg<i:
11 |         print((st*(2*(n-i)+1)).center(k,st1))
12 | 


--------------------------------------------------------------------------------
/Find the Runner-Up Score!.py:
--------------------------------------------------------------------------------
 1 | if __name__ == '__main__':
 2 |     n = int(input())
 3 |     arr = list(map(int, input().split()))
 4 |     arr.sort()
 5 |     max1=arr[-1]
 6 |     arr.sort(reverse=True)
 7 |     for x in arr:
 8 |         if x!=max1:
 9 |             result = x
10 |             print(result)
11 |             break
12 |     
13 | 


--------------------------------------------------------------------------------
/Text Wrap.py:
--------------------------------------------------------------------------------
 1 | import textwrap
 2 | 
 3 | def wrap(string, max_width):
 4 |     s= ''
 5 |     for i in range(0,len(string),max_width):
 6 |         s=s + string[i:i+max_width]+"\n"
 7 |     return s
 8 | 
 9 | if __name__ == '__main__':
10 |     string, max_width = input(), int(input())
11 |     result = wrap(string, max_width)
12 |     print(result)
13 | 


--------------------------------------------------------------------------------
/Exceptions.py:
--------------------------------------------------------------------------------
 1 | test_case = int(input(""))
 2 | for o in range(test_case):
 3 |     try:
 4 |         a ,b = map(int ,input("").split(" "))
 5 |         print(int(a/b))
 6 |     except ZeroDivisionError as e:
 7 |         print("Error Code: integer division or modulo by zero")
 8 |     except ValueError as e1:
 9 |         print("Error Code:",e1)
10 |     
11 |     
12 | 


--------------------------------------------------------------------------------
/Any or All.py:
--------------------------------------------------------------------------------
1 | ###1st Condition - All number must be Positive 
2 | ###2nd Condition - Atleast one number must be Palidrome
3 | N =int(input(""))
4 | n = list(map(int , input("").split(" ")))
5 | if (all(i>0 for i in n) and any(str(i)==str(i)[::-1] for i in n)):#if all the numbers is positive then it will return True    
6 |     print(bool(1))
7 | else:
8 |     print(bool(0))
9 | 


--------------------------------------------------------------------------------
/Python If-Else.py:
--------------------------------------------------------------------------------
 1 | #!/bin/python3
 2 | 
 3 | import math
 4 | import os
 5 | import random
 6 | import re
 7 | import sys
 8 | n = int(input().strip())
 9 | 
10 | if n%2==1:
11 |     print("Weird")
12 | elif n%2==0 and (n>= 2 and n<6):
13 |     print("Not Weird")
14 | elif n%2==0 and (n>6 and n<21):
15 |     print("Weird")
16 | else:
17 |     print("Not Weird")
18 | 


--------------------------------------------------------------------------------
/itertools.permutations().py:
--------------------------------------------------------------------------------
 1 | # Enter your code here. Read input from STDIN. Print output to STDOUT
 2 | import itertools as it
 3 | itere , n =input("").split(" ")
 4 | lst1 =(list(i for i in itere))
 5 | str(lst1.sort())
 6 | n=int(n)
 7 | lst = list( x for x in it.permutations(lst1 , n))
 8 | for i in lst:
 9 |     m = ""
10 |     for j in i:
11 |         m+=j
12 |     print(m)
13 | 
14 | 


--------------------------------------------------------------------------------
/Write a function.py:
--------------------------------------------------------------------------------
 1 | def is_leap(year):
 2 |     leap = False
 3 |     if (year % 4) == 0:
 4 |         if (year % 100) == 0:
 5 |             if (year % 400) == 0:
 6 |                 return True
 7 |             else:
 8 |                 return leap
 9 |         else:
10 |             return True
11 |     else:
12 |         return leap
13 | 
14 | year = int(input())
15 | print(is_leap(year))
16 | 


--------------------------------------------------------------------------------
/itertools.combinations_with_replacement().py:
--------------------------------------------------------------------------------
 1 | from itertools import combinations_with_replacement
 2 | lst , n = input("").split(" ")
 3 | n= int(n)
 4 | lst1 = list(x for x in lst)
 5 | lst1.sort()
 6 | lst = ''
 7 | for j in lst1:
 8 |     lst+=j
 9 | final = list(m for m in combinations_with_replacement(lst,n))
10 | for x in final:
11 |     s=''
12 |     for i in x:
13 |         s+=i
14 |     print(s)
15 | 


--------------------------------------------------------------------------------
/Set .discard(), .remove() & .pop().py:
--------------------------------------------------------------------------------
 1 | n = int(input())
 2 | s = set(map(int, input().split(" ")))
 3 | m = int(input())
 4 | for i in range(0,m):
 5 |     x=list(input().split(" "))
 6 |     if x[0]=="pop":
 7 |         s.pop()
 8 |     elif x[0]=="remove":
 9 |         j = int(x[1])
10 |         s.remove(j)
11 |     elif x[0]=="discard":
12 |         j = int(x[1])
13 |         s.discard(j)
14 | print(sum(s))
15 | 


--------------------------------------------------------------------------------
/itertools.combinations().py:
--------------------------------------------------------------------------------
 1 | import itertools as it
 2 | iterr ,n = input().split(" ")
 3 | lst1= list(i for i in iterr)
 4 | str(lst1.sort())
 5 | result = []
 6 | for i in range(1,int(n)+1):
 7 |     x = list(m for m in it.combinations(lst1, i))
 8 |     result.append(x)
 9 | for m in range(len(result)):
10 |     for j in result[m]:
11 |         for k in j:
12 |             print(k, end ="" )
13 |         print()
14 | 


--------------------------------------------------------------------------------
/No Idea!.py:
--------------------------------------------------------------------------------
 1 | n , m = map(int , input("").split(" "))
 2 | n_list=list(map(int , input("").split(" ")))
 3 | Set_A=set(int(x) for x in input("").split(" "))
 4 | Set_B = set(int(x) for x in input("").split(" "))
 5 | result=0
 6 | for i in n_list:
 7 |     if i in Set_A:
 8 |         result+=1
 9 |     elif i in Set_B:
10 |         result-=1
11 |     elif i not in Set_B and i not in Set_A:
12 |         pass
13 | print(result)
14 | 


--------------------------------------------------------------------------------
/Merge the Tools!.py:
--------------------------------------------------------------------------------
 1 | def merge_the_tools(string, k):
 2 |     for i in range(len(string)//k):
 3 |         s=string[k*i:k*i+k]
 4 |         l=[i for i in s]
 5 |         a=''
 6 |         for i in l:
 7 |             if i not in a:
 8 |                 a+= i
 9 |         print(a)
10 |     #    print(s)
11 |     
12 | 
13 | if __name__ == '__main__':
14 |     string, k = input(), int(input())
15 |     merge_the_tools(string, k)
16 | 


--------------------------------------------------------------------------------
/List Comprehensions.py:
--------------------------------------------------------------------------------
 1 | if __name__ == '__main__':
 2 |     x = int(input())
 3 |     y = int(input())
 4 |     z = int(input())
 5 |     n = int(input())
 6 |     final_list =[]
 7 |     for i in range(1+x):
 8 |         for j in range(y+1):
 9 |             for k in range(1+z):
10 |                 if i+j+k!=n:
11 |                     temp=[i,j,k]
12 |                     final_list.append(temp)
13 |                 else:
14 |                     continue
15 |     print(final_list)
16 | 


--------------------------------------------------------------------------------
/Find a string.py:
--------------------------------------------------------------------------------
 1 | def count_substring(string, sub_string):
 2 |     len_SubString= len(sub_string)
 3 |     result = 0
 4 |     for i in range(len(string)+1-len_SubString):
 5 |         if string[i:i+len_SubString]==sub_string:
 6 |             result+=1
 7 |         else:
 8 |             continue
 9 |     
10 |     return result
11 | 
12 | if __name__ == '__main__':
13 |     string = input().strip()
14 |     sub_string = input().strip()
15 |     
16 |     count = count_substring(string, sub_string)
17 |     print(count)
18 | 


--------------------------------------------------------------------------------
/Check Subset.py:
--------------------------------------------------------------------------------
 1 | def Subset(a,b):
 2 |     result = 0
 3 |     for i in a:
 4 |         if i in b:
 5 |             result = 1
 6 |         else:
 7 |             result = 0
 8 |             break
 9 |     return True if result == 1 else False# Using Ternary Operator
10 | 
11 | test_case = int(input(""))
12 | for i in range(test_case):
13 |     a= int(input(""))
14 |     seta = set(int(x) for x in input().split(" "))
15 |     b =int(input(""))
16 |     setb = set(int(x) for x in input().split(" "))
17 |     print(Subset(seta , setb))
18 | 


--------------------------------------------------------------------------------
/Finding the percentage.py:
--------------------------------------------------------------------------------
 1 | if __name__ == '__main__':
 2 |     n = int(input())
 3 |     student_marks = {}
 4 |     for _ in range(n):
 5 |         name, *line = input().split()
 6 |         scores = list(map(float, line))
 7 |         student_marks[name] = scores
 8 |     query_name = input()
 9 |     for i in student_marks:
10 |         j = student_marks.get(i)
11 |         if i==query_name:
12 |             result = 0
13 |             for k in j:
14 |                 result+= float(k)
15 |             print("{:.2f}".format((result/len(j))))
16 |             break
17 |         else:
18 |             continue
19 | 


--------------------------------------------------------------------------------
/Words Score.py:
--------------------------------------------------------------------------------
 1 | def is_vowel(letter):
 2 |     return letter in ['a', 'e', 'i', 'o', 'u', 'y']
 3 | def score_words(arr):
 4 |     final=0
 5 |     for word in arr:
 6 |         s=0
 7 |         result =0#if s is odd then add 1 otherwise add 2
 8 |         for i in word:
 9 |             if is_vowel(i):
10 |                 s+=1
11 |             else:
12 |                 pass
13 |         if s&1==1:
14 |             result+=1
15 |         else:
16 |             result+=2
17 |         final+=result
18 |     return final
19 | 
20 | n = int(input())
21 | words = input().split()
22 | print(score_words(words))
23 | 


--------------------------------------------------------------------------------
/Nested Lists.py:
--------------------------------------------------------------------------------
 1 | if __name__ == '__main__':
 2 |     final_list =[]
 3 |     marks=[]
 4 |     for _ in range(int(input())):
 5 |         l= list()
 6 |         l.append(input())
 7 |         score = float(input())
 8 |         l.append(score)
 9 |         marks.append(score)
10 |         final_list.append(l)
11 |     marks.sort()
12 |     min_value = marks[0]
13 |     marks.remove(min_value)
14 |     for i in marks:
15 |         if i>min_value:
16 |             Result_value = i
17 |             break
18 |     Result_names=[]
19 |     for i in range(len(final_list)):
20 |         if Result_value in final_list[i]:
21 |             Result_names.append(final_list[i][0])
22 |     Result_names.sort()
23 |     for i in Result_names:
24 |         print(i)
25 | 


--------------------------------------------------------------------------------
/ginortS.py:
--------------------------------------------------------------------------------
 1 | string = input("")
 2 | lower = list()
 3 | lower1 =['a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z']
 4 | 
 5 | upper = list()
 6 | upper1 = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z']
 7 | odd = list()
 8 | even= list()
 9 | number =['1','2','3','4','5','6','7','8','9','0']
10 | for i in string:
11 |     if i in lower1:
12 |         lower.append(i)
13 |     elif i in upper1:
14 |         upper.append(i)
15 |     elif i in number:
16 |         even.append(i) if (int(i)%2==0) else odd.append(i)
17 | lower.sort()
18 | upper.sort()
19 | even.sort()
20 | odd.sort()
21 | final = lower + upper + odd+even
22 | for i in final:
23 |     print(i,end = '')
24 | 


--------------------------------------------------------------------------------
/Capitalize!.py:
--------------------------------------------------------------------------------
 1 | #!/bin/python3
 2 | 
 3 | import math
 4 | import os
 5 | import random
 6 | import re
 7 | import sys
 8 | 
 9 | # Complete the solve function below.
10 | def solve(s):
11 |     sa=""
12 |     #Method_2
13 |     sa+=s[0].upper()
14 |     for i in range(1,len(s)):
15 |         if s[i]==" ":
16 |             sa+=s[i]
17 |         elif s[i-1]==" ":
18 |             if s[i]==" ":
19 |                 sa+=s[i]
20 |             else:
21 |                 sa+=s[i].upper()
22 |         else:
23 |             sa+=s[i]
24 |     return sa
25 | 
26 | 
27 |         
28 | 
29 | if __name__ == '__main__':
30 |     fptr = open(os.environ['OUTPUT_PATH'], 'w')
31 | 
32 |     s = input()
33 | 
34 |     result = solve(s)
35 | 
36 |     fptr.write(result + '\n')
37 | 
38 |     fptr.close()
39 | 


--------------------------------------------------------------------------------
/Lists.py:
--------------------------------------------------------------------------------
 1 | if __name__ == '__main__':
 2 |     lst = []
 3 |     N = int(input())
 4 |     for i in range(N):
 5 |         mn= list(input("").split(" "))
 6 |         
 7 |         if mn[0]=="insert":
 8 |             a , b = map(int , (mn[1],mn[2]))
 9 |             lst.insert(a,b)
10 |             
11 |         elif mn[0]=="print":
12 |             print(lst)
13 |             
14 |         elif mn[0]=="remove":
15 |                 lst.remove(int(mn[1]))
16 | 
17 |         elif mn[0]=="append":
18 |             lst.append(int(mn[1]))
19 |             
20 |         elif mn[0]=="sort":
21 |             lst.sort()
22 |         
23 |         elif mn[0]=="pop":
24 |             
25 |             lst.pop()
26 |         elif mn[0]=="reverse":
27 |             lst.reverse()
28 |             
29 |             
30 | 
31 |                 
32 | 


--------------------------------------------------------------------------------
/Default Arguments.py:
--------------------------------------------------------------------------------
 1 | class EvenStream(object):
 2 |     def __init__(self):
 3 |         self.current = 0
 4 | 
 5 |     def get_next(self):
 6 |         to_return = self.current
 7 |         self.current += 2
 8 |         return to_return
 9 | 
10 | class OddStream(object):
11 |     def __init__(self):
12 |         self.current = 1
13 | 
14 |     def get_next(self):
15 |         to_return = self.current
16 |         self.current += 2
17 |         return to_return
18 | 
19 | def print_from_stream(n, stream=EvenStream()):
20 |     stream.__init__()
21 |     for _ in range(n):
22 |         print(stream.get_next())
23 | 
24 | 
25 | queries = int(input())
26 | for _ in range(queries):
27 |     stream_name, n = input().split()
28 |     n = int(n)
29 |     if stream_name == "even":
30 |         print_from_stream(n)
31 |     else:
32 |         print_from_stream(n, OddStream())
33 | 


--------------------------------------------------------------------------------
/Set Mutations.py:
--------------------------------------------------------------------------------
 1 | # Enter your code here. Read input from STDIN. Print output to STDOUT
 2 | n = int(input(""))
 3 | seta = set(map(int , input("").split(" ")))
 4 | j = int(input(""))
 5 | for i in range(j):
 6 |     ian = list(input().split())
 7 |     if ian[0]== "intersection_update":
 8 |         fi = set(int(x) for x in input('').split(" ")) 
 9 |         seta.intersection_update(fi)
10 | 
11 |     elif ian[0] == "symmetric_difference_update":
12 |         fi = set(int(x) for x in input('').split(" "))
13 |         seta.symmetric_difference_update(fi)
14 | 
15 |     elif ian[0] == "update":
16 |         fi = set(int(x) for x in input('').split(" "))
17 |         seta.update(fi)
18 | 
19 |     elif ian[0] == "difference_update":
20 |         fi = set(int(x) for x in input('').split(" "))
21 |         seta.difference_update(fi)
22 | res = 0
23 | for m in seta:
24 |     res+=m
25 | print(res)
26 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | Hello, <br>I'm happy to see you in my GitHub.
 2 | <br>I hope this repo helped you.
 3 | <br>If you feel this repo helped you, please endore me for Python on LinkedIn 
 4 | ### Steps for endorsement :- Open my [LinkedIn ID](https://www.linkedin.com/in/avisikta-majumdar/) --> Scroll Down to Skills --> Endorse for Python .
 5 | 
 6 | 
 7 | ## About StrataScratch
 8 | It is a platform which provides you the opportunity to improve your coding skills, prepare for interviews, and jump-start for your career as well.
 9 | ### [Register Now & start improving yourself with StrataScratch](https://stratascratch.com/?via=AvisiktaMajumdar)
10 | 
11 | 
12 | ## Let's connect over [LinkedIn](https://www.linkedin.com/in/avisikta-majumdar/)
13 | 
14 | ## If you are looking for Job Guarantee program in Data Science, I think this course will help you to achieve you dream job.
15 | ### [Almabetter Full Stack Data Science Program](https://grow.almabetter.com/auth/signup?referralCode=4M11C2&utm_source=referral)
16 | 


--------------------------------------------------------------------------------
/Alphabet Rangoli.py:
--------------------------------------------------------------------------------
 1 | def print_rangoli(size):
 2 |     width= (size+(size-1)+2*(size-1))
 3 |     n=size
 4 |     for i in range(n):
 5 |         s=''
 6 |         ch=96+n
 7 |         mid= ((2*i+1)//2)
 8 |         for j in range(2*i+1):
 9 |             s+=chr(ch)
10 |             if j<mid:
11 |                 ch-=1
12 |             else:
13 |                 ch+=1
14 | 
15 |             if j<(2*i):
16 |                 s+='-'
17 |             else:
18 |                 pass
19 |         print(s.center(width,'-'))
20 |     for i2 in range(1,n):
21 |         s=''
22 |         ch=96+n
23 |         mid= ((1+2*(n-1-i2))//2)
24 |         for j2  in range(1+2*(n-1-i2)):
25 |             s+=chr(ch)
26 |             if j2<mid:
27 |                 ch-=1
28 |             else:
29 |                 ch+=1
30 | 
31 |             if j2<(2*(n-1-i2)):
32 |                 s+='-'
33 |             else:
34 |                 pass
35 | 
36 |         print(s.center(width,'-'))
37 | if __name__ == '__main__':
38 |     n = int(input())
39 |     print_rangoli(n)
40 | 


--------------------------------------------------------------------------------