Structuring Things

Author: Dhrumil-Zion

Adding_Ones.py

@@ -2,18 +2,15 @@
 link = "https://practice.geeksforgeeks.org/problems/adding-ones3628/1#"
 """
 
+
 c = [0,0,0]             ##### Optimized code for below program
 updates = [1,1,2,3]
 k = 4
 n = 3
-i = 0
-while (i<k):
+for i in range(k):
     c[updates[i]-1] +=1
-    i +=1
-i = 1    
-while (i<n):
+for i in range(1, n):
     c[i]+=c[i-1]
-    i +=1
 print(c)
 
 
@@ -22,11 +19,9 @@
 l1 = inp1[0] + 1
 l2 = inp1[1]
 final_arr = inp2[:l2]
-arr  = []
 count = 0
 
-for x in range(l1):
-    arr.append(0)
+arr = [0 for _ in range(l1)]
 for y in final_arr:
     for x in range(1,l1):
         if y <= x:

Advance_String.py

@@ -12,10 +12,9 @@ def subString(s):
     for x in final:
         length = len(x)
         disticnt_char = len(set(x))
-        eq = eq + pow(length,disticnt_char)%100000007
+        eq += pow(length,disticnt_char)%100000007
 
     return int(eq%100000007)
-  
 
 s = "ddddddddddddddddddeeeeeeeeeeeeeeeeeeiiiiiiiiiiiiiiiiiiyyyyyyyyyyyyyyyyyyiyd"
 ans = subString(s)

Apples_Orange_Problem.py

@@ -3,8 +3,8 @@
 """
 
 def method_3(s,t,a,b,apples,oranges):          #### Optimized Code ####
-    print(sum([1 for x in apples if (x + a) >= s and (x + a) <= t]))
-    print(sum([1 for x in oranges if (x + b) >= s and (x + b) <= t]))
+    print(sum((x + a) >= s and (x + a) <= t for x in apples))
+    print(sum((x + b) >= s and (x + b) <= t for x in oranges))
 
 def method_4(s,t,a,b,apples,oranges):           #### Optimized Code ####
     print(sum(s <= a + d <= t for d in apples))
@@ -16,12 +16,9 @@ def method_1(s,t,a,b,apples,oranges):           #### time Complexity exceeds in
     count_apples =0
     count_oragnes =0
     y = (t-s)+1
-    le_app = 0 
+    le_app = 0
     x = 0
-    if len(apples) >= len(oranges):
-        le_app = len(apples)
-    else:
-        le_app = len(oranges)    
+    le_app = max(len(apples), len(oranges))
     while(y!=0):
         house_arr.append(temp)
         temp +=1
@@ -36,7 +33,7 @@ def method_1(s,t,a,b,apples,oranges):           #### time Complexity exceeds in
             if oranges[x] in house_arr:
                 count_oragnes +=1
         x +=1
-        le_app -=1           
+        le_app -=1
     print(count_apples)
     print(count_oragnes)          
 
@@ -45,14 +42,14 @@ def method_2(s,t,a,b,apples,oranges):               #### time Complexity exceeds
     temp = s
     count_apples =0
     count_oragnes =0
-    for x in range((t-s)+1):
+    for _ in range(t - temp + 1):
         house_arr.append(temp)
         temp +=1
-    print(house_arr)    
+    print(house_arr)
     for x in range(len(apples)):
         apples[x] = apples[x] + a
         if apples[x] in house_arr:
-            count_apples +=1        
+            count_apples +=1
     for x in range(len(oranges)): 
         oranges[x] = oranges[x] + b
         if oranges[x] in house_arr:

Between Two Set.py

@@ -4,20 +4,13 @@ def getTotalX(a, b):
     prepre = []
     lis = [x for x in range(a[-1],b[0]+1)]
     for x in lis:
-        c=0
-        for y in a:
-            if x%y==0:
-                c+=1
+        c = sum(x%y==0 for y in a)
         if c == len(a):
             s=0
     for x in pre:
-        c=0
-        for y in b:
-            if y%x==0:
-                c+=1
+        c = sum(y%x==0 for y in b)
         if c==len(b):
-            s+=1        
-           
+            s+=1
     print(s)        
 
 

Count_Sum.py

@@ -13,31 +13,31 @@
 
 def processing(n,sum,arr):
     temp = 0
-    final = [] 
+    final = []
     t = 0
     for y in arr:
         t = y
-        for x in range(n):
-            temp = temp + (int(t)%10)
+        for _ in range(n):
+            temp += int(t)%10
             t = int(t/10)
-        t = 0    
+        t = 0
         if temp == sum:
             final.append(y)
-        temp = 0        
+        temp = 0
     print(final)
     print("Count  = {}".format(len(final)))
     final.clear()        
 
 def getCount(n,sum):
-    arr = [] 
+    arr = []
     if n == 2:
         arr = range(11,100)
-        processing(n,sum,arr)    
     else: 
         start = math.pow(10,n-1)
-        end = start * 10 
+        end = start * 10
         arr = range(int(start),int(end))
-        processing(n,sum,arr)
+
+    processing(n,sum,arr)
 
 getCount(2,3)
 getCount(3,3)

Counting_Vally.py

@@ -3,12 +3,12 @@ def countingValleys(steps, path):
     count = 0
     for x in range(steps):
         if path[x]=='D' and sealevel ==0:
-            sealevel = sealevel - 1
+            sealevel -= 1
             count +=1
         elif path[x] == 'D':
-            sealevel = sealevel - 1
+            sealevel -= 1
         elif path[x] == 'U':
-            sealevel = sealevel + 1    
+            sealevel += 1
     return count
 
 a = "UDDDUDUU"

Find_Digits.py

@@ -44,19 +44,15 @@ def caesarCipher(s, k):
     e = []
     for item in l:
         z = ord(item)
-        if (z >= 97 and z<=122):
-            if (z+k) > 122:
-                e.append(chr(96 + (z+k-122)))
-            else:
-                e.append(chr(z+k))
-        elif (z>=65 and z<=90):
-            if (z+k) > 90:
-                e.append(chr(64 + (z+k-90)))
-            else:
-                e.append(chr(z+k))
+        if (z >= 97 and z <= 122) and (z + k) > 122:
+            e.append(chr(96 + (z+k-122)))
+        elif z >= 97 and z <= 122 or z >= 65 and z <= 90 and z + k <= 90:
+            e.append(chr(z+k))
+        elif z >= 65 and z <= 90:
+            e.append(chr(64 + (z+k-90)))
         else:
             e.append(item)
-    print("".join([x for x in e]))
+    print("".join(e))
 
 
 s ="middle-Outz"

Grading_Problem.py

@@ -5,7 +5,7 @@
         if grades[x]<38:
             continue
         while t%5!=0:
-           t +=1
+            t +=1
         if (t - temp) < 3:
             grades[x]=t
 print(grades)

infosys_1.py renamed to HackWithInfy 2021/infosys_1.py

@@ -4,21 +4,21 @@ def howManyGames(p, d, m, s):
     deduction = d
     minprice = m
     c=0
-    while(1):
+    while 1:
         budget = budget - price
         if budget>=0:
             price = price -deduction
             if price>minprice:
                 c+=1
                 continue
-            elif price<=minprice:
+            else:
                 if budget >= price-minprice:
                     c+=1
                     price = minprice
                 else:
-                    break    
+                    break
         else:
-            break        
+            break
     print(c)        
 
 p = 20 

infosys_11.py renamed to HackWithInfy 2021/infosys_11.py

@@ -2,33 +2,26 @@
 link = https://www.hackerrank.com/challenges/kangaroo/problem
 """
 def kangaroo_optimization(x1, v1, x2, v2):
-    y=0
-    while (y<10000):
+    for y in range(10000):
         if x1 + y * v1 == x2 + y * v2:
             return "YES"
-        y+=1
     return "NO"          
-             
 
 def kangaroo(x1, v1, x2, v2):
     diff1 =v1
     diff2 = v2
-    k=0
     flag = 0
-    while k<10000:
+    for k in range(10000):
         if (x2 > x1 and v2>v1) or (x1>x2 and v1>v2):
             return "NO"
-            break
         a = x1+v1
         b = x2+v2
         if a==b:
             return "YES"
-            break
         v1 = v1 + diff1
         v2 = v2 + diff2
         if k == 9999:
-            flag=1 
-        k+=1    
+            flag=1
     if flag ==1:
         return "NO"   
 

infosys_2.py renamed to HackWithInfy 2021/infosys_2.py

@@ -21,10 +21,7 @@ def luckBalance(k, contests):
 
     k = int(nk[1])
 
-    contests = []
-
-    for _ in range(n):
-        contests.append(list(map(int, input().rstrip().split())))
+    contests = [list(map(int, input().rstrip().split())) for _ in range(n)]
 
     result = luckBalance(k, contests)
 

infosys_3.py renamed to HackWithInfy 2021/infosys_3.py

@@ -1,21 +1,11 @@
 arr = [1 ,2, 3, 4, 5, 4, 3, 2, 1, 3, 4]
-my_dict = {}
 uni = set(arr)
-for x in uni:
-    my_dict[x] = arr.count(x)
-
+my_dict = {x: arr.count(x) for x in uni}
 my_dict.fo
 print(my_dict.values())
 
 
 
-
-
-
-
-
-
-
 # for x in uni:
 #     a.append(arr.count(x))
 # for x in range(len(uni)):

Halloween Sale.py

@@ -1,14 +1,13 @@
 def cutTheSticks(arr):
-    ans = []
-    ans.append(len(arr))
+    ans = [len(arr)]
     while 1:
         z = min(arr)
         for x in range(len(arr)):
             arr[x] = arr[x]-z
-        arr = list(filter(lambda x: x != 0, arr))     
-        if len(arr) == 0:
-            break    
-        ans.append(len(arr))    
+        arr = list(filter(lambda x: x != 0, arr))
+        if not arr:
+            break
+        ans.append(len(arr))
     print(ans)
 
 arr = [1 ,2 ,3 ,4, 3, 3, 2, 1]

Kangaroo_problem.py

@@ -3,9 +3,7 @@ def isPalindrome(s):                #### Optimized way ####
 
 def isPalindrome_third(s):           #### Optimized way ####
 	rev = ''.join(reversed(s))
-	if (s == rev):
-		return True
-	return False
+	return (s == rev)
 
 def isPalindrom_fifth(s):        #### for numbers only ####
     temp=s
@@ -30,10 +28,7 @@ def isPalindrom_one(i):                 #### Un-Optimized way Strings only####
         print("Not")  
 
 def isPalindrome_second(str):               #### Un-Optimized way ####
-	for i in range(0, int(len(str)/2)): 
-		if str[i] != str[len(str)-i-1]:
-			return False
-	return True
+	return all(str[i] == str[len(str)-i-1] for i in range(int(len(str)/2)))
 
 def isPalindrom_fourth(s):             #### Un-Optimized way Strings only ####
     w = ""
@@ -44,7 +39,6 @@ def isPalindrom_fourth(s):             #### Un-Optimized way Strings only ####
     else:
         print("No")
 
-
 s = "malayalam"
 
 isPalindrom_one(s)

Luck Balance.py

@@ -1,23 +1,21 @@
 ######################################### For Numbers Only #########################################
 
 def reverseNumber(s):
-    st = 0 
-    en = -1 
-    for x in range(int(len(s)/2)):
+    en = -1
+    for st, _ in enumerate(range(int(len(s)/2))):
         s[st],s[en] = s[en],s[st]
-        st = st + 1
-        en = en - 1
+        en -= 1
     print(s)     
 
 ######################################### For Strings Only #########################################
 
 def reverseWord(s):
     j = -1
     k = ""
-    for x in range(len(s)-1):
-        k = k + s[j]
-        j = j - 1
-    k = k + s[-len(s)]
+    for _ in range(len(s)-1):
+        k += s[j]
+        j -= 1
+    k += s[-len(s)]
     print(k) 
 
 def reverse(s):