GFG Improvements - Pending for publications

Author: absognety

GFG_Publications/GFG_Contributions_Pending/Sub_Sequences_of_String.py

@@ -0,0 +1,18 @@
+import itertools
+
+def Sub_Sequences(STR):
+    combs = []
+    for l in range(1,len(STR)+1):
+        combs.append(list(itertools.combinations(STR,l)))
+    for c in combs:
+        for t in c:
+            print (''.join(t),end=' ')
+
+
+if __name__ == '__main__':
+    Sub_Sequences('geek')
+    Sub_Sequences('geeks')
+    Sub_Sequences('geeksforgeeks')
+    Sub_Sequences('hackerrank')
+    Sub_Sequences('hackerearth')
+    Sub_Sequences('codechef')

GFG_Publications/GFG_Contributions_Pending/decryptString.py

@@ -0,0 +1,54 @@
+
+def encrypted_string(strg):
+    EncryptedString = [strg[0]]
+    for t in range(1,len(strg)):
+        if (t%2 == 1):
+            EncryptedString.append(strg[t])
+        else:
+            EncryptedString.insert(0,strg[t])
+    return (''.join(EncryptedString))
+
+print (encrypted_string('geeks'))
+print (encrypted_string('geeksforgeeks'))
+print (encrypted_string('strive'))
+print (encrypted_string('vikaschitturi'))
+print (encrypted_string('padmachitturi'))
+print (encrypted_string('hackerrank'))
+print (encrypted_string('hackerearth'))
+print (encrypted_string('codechef'))
+print (encrypted_string('IamVikas'))
+print (encrypted_string('HelloHowareyou'))
+print (encrypted_string('whatareyoudoing'))
+
+
+
+
+def decrypted_string(strg):
+    if (len(strg)%2!=0):
+        DecryptedString = [strg[0]]
+        for t in range(1,len(strg)):
+            DecryptedString.append(strg[-1*t])
+            DecryptedString.append(strg[t])
+        DecryptedString = DecryptedString[:len(strg)][::-1]
+        return (''.join(DecryptedString))
+    else:
+        reverse_strg = strg[::-1]
+        DecryptedString=[reverse_strg[0]]
+        for t in range(1,len(reverse_strg)):
+            DecryptedString.append(reverse_strg[-1*t])
+            DecryptedString.append(reverse_strg[t])
+        DecryptedString = DecryptedString[:len(reverse_strg)][::-1]
+        return (''.join(DecryptedString))
+    
+    
+print(decrypted_string('segek'))
+print(decrypted_string('segosegekfrek'))
+print(decrypted_string('vrstie'))
+print(decrypted_string('iuthskviacitr'))
+print(decrypted_string('iuthadpamcitr'))
+print(decrypted_string('nrechakrak'))
+print(decrypted_string('hreechakrat'))
+print(decrypted_string(encrypted_string('IamVikas')))
+print(decrypted_string(encrypted_string('HelloHowareyou')))
+print(decrypted_string(encrypted_string('whatareyoudoing')))
+

GFG_Publications/GFG_Contributions_Pending/minSteps_in_InfiniteGrid.py

@@ -0,0 +1,18 @@
+#Traversing from one point to another point
+#storing the minimum number of steps
+def traversal_steps(A,B):
+    points = list(zip(A,B))
+    minSteps = 0
+    for p in range(len(points)-1):
+        #taking the manhattan distance between x and y-coordinates 
+        d1 = abs(points[p][0] - points[p+1][0])
+        d2 = abs(points[p][1] - points[p+1][1])
+        #adding the maximum among the two to the running steps parameter
+        minSteps += max(d1,d2)
+    return (minSteps)
+ 
+#Main Driver Code
+if __name__ == '__main__':
+    A = list(map(int,input().strip().split()))
+    B = list(map(int,input().strip().split()))
+    print (traversal_steps(A,B))

GFG_Publications/GFG_Contributions_Pending/minimizeReplacements_string.py

@@ -0,0 +1,99 @@
+"""
+Minimize the number of replacements to get a string with 
+same number of ‘a’, ‘b’ and ‘c’ in it
+"""
+def minimize_replacements(STR):
+    #Count of a's, b's and c's in a given string
+    count_a = STR.count('a')
+    count_b = STR.count('b')
+    count_c = STR.count('c')
+    # if three of them are equal return the same string
+    if count_a == count_b == count_c:
+        return (STR)
+    
+    #if not a multiple of 3 then return -1
+    if len(STR)%3 != 0:
+        return -1
+    #Increase the number of a's by 
+    #removing extra 'b' and ;c;
+    i=0
+    s = list(STR)
+    while ((count_a < len(STR)//3) & (i < len(STR))):
+        #Check if it is 'b' and it more than n/3
+        if ((STR[i]=='b') & (count_b > len(STR)//3)):
+            count_b-=1
+            s[i]='a'
+            count_a+=1
+        #Check if it is 'c' and it more than n/3 
+        elif ((STR[i]=='c') & (count_c > len(STR)//3)):
+            count_c-=1
+            s[i]='a'
+            count_a+=1
+        i+=1
+    
+    
+    i=0
+    STR = ''.join(s)
+    t = list(STR)
+    #Increase the number of b's by removing extra 'c' 
+    while ((count_b < len(STR)//3) & (i < len(STR))):
+        #Check if it is 'c' and it more than n/3 
+        if ((STR[i] == 'c') & (count_c > len(STR)//3)):
+            count_c-=1 
+            t[i]='b'
+            count_b+=1
+        i+=1
+    
+    
+    i = len(STR) - 1
+    STR = ''.join(t)
+    u = list(STR)
+    #Increase the number of c's from back 
+    while ((count_c < len(STR)//3) & (i >= 0)):
+        #Check if it is 'a' and it more than n/3 
+        if ((STR[i] == 'a') & (count_a > len(STR)//3)):
+            count_a-=1
+            u[i] = 'c'; 
+            count_c+=1 
+        i-=1
+        
+    
+    
+    i = len(STR) - 1 
+    STR = ''.join(u)
+    v = list(STR)
+    #Increase the number of b's from back 
+    while ((count_b < len(STR)//3) & (i >= 0)):
+        #Check if it is 'a' and it more than n/3 
+        if ((STR[i] == 'a') & (count_a > len(STR)//3)):
+            count_a-=1 
+            v[i] = 'b' 
+            count_b+=1
+        i-=1
+        
+        
+    
+    i = len(STR) - 1
+    STR = ''.join(v)
+    w = list(STR)
+    #Increase the number of c's from back 
+    while ((count_c < len(STR)//3) & (i >= 0)):
+        #Check if it is 'b' and it more than n/3 
+        if ((STR[i] == 'b') & (count_b > len(STR)//3)):
+            count_b-=1
+            w[i] = 'c'
+            count_c+=1
+        i-=1
+        
+        
+    STR = ''.join(w)
+    return STR
+    
+
+if __name__ == '__main__':
+    print (minimize_replacements('bcabba'))
+    print (minimize_replacements('aaaaaa'))
+    print (minimize_replacements('aabcbabbc'))
+    print (minimize_replacements('aaabcbcbc'))
+    print (minimize_replacements('aaaaa'))
+