Added a new algorithm within strings module

README.md

@@ -356,6 +356,7 @@ If you want to uninstall algorithms, it is as simple as:
  - [longest_palindromic_substring](algorithms/strings/longest_palindromic_substring.py)
  - [knuth_morris_pratt](algorithms/strings/knuth_morris_pratt.py)
  - [panagram](algorithms/strings/panagram.py)
+ - [swapcharacters](algorithms/strings/swap_str.py)
 - [tree](algorithms/tree)
  - [bst](algorithms/tree/bst)
  - [array_to_bst](algorithms/tree/bst/array_to_bst.py)

algorithms/strings/swap_str.py

@@ -0,0 +1,71 @@
+"""
+Given two strings s1 and s2, we are allowed to swap only one character from s1 with that of s2
+such that after the swap, the total number of distinct characters in both s1 and s2 are the same.
+If it is possible to perform such a swap, we should return True, else return False.
+
+Example 1:
+String 1: "cd", String 2: "e"
+Expected Output: False
+Explanation: On swapping the character c with e, we will end up with 2 distinct characters in string 1
+and 1 character in string 2. Same goes with swapping character d with e.
+
+Example 2:
+String 1: "deff", String 2: "dde"
+Expected Output: True
+Explanation: We can swap character f in string 1 with character d in string 2. Hence, the new strings
+will be dedf and fde. Both the string will contain three distinct characters, i.e. f, d and e.
+
+Approach:
+Create distinct prefix arrays for both string 1 and string 2. Then apply brute force to swap each of the
+characters of string 1 with that of string 2 and notice if the number of distinct characters are the same.
+If yes, then return True. Else, return False after all the swaps are complete.
+
+If N is the size of string 1 and M is the size of string 2, then:
+
+Time Complexity: O(N+M+26*26), where a complexity of N+M is required to create the prefix arrays. Also,
+26*26 different swaps are required in the worst case scenario.
+
+Space Complexity: O(26+26)=O(52) for creating the prefix arrays.
+"""
+
+# Function to create the Prefix Array.
+def createPrefixArray(string):
+ array,count=[0]*26,0
+ for w in string:
+ array[ord(w)-ord('a')]+=1
+ if array[ord(w)-ord('a')]==1:
+ count+=1
+ return array,count
+
+def checkSwapEquality(string1,string2):
+ prefixArray1,leftCount=createPrefixArray(string1) # Time Complexity of O(N)
+ prefixArray2,rightCount=createPrefixArray(string2) # Time Complexity of O(M)
+ for i in range(26): # Time Complexity of O(26*26)
+ if prefixArray1[i]: # Enter only if the character count is greater than 0
+ prefixArray1[i]-=1
+ if prefixArray1[i]==0:
+ leftCount-=1
+ prefixArray2[i]+=1
+ if prefixArray2[i]==1:
+ rightCount+=1
+ for j in range(26):
+ l,r=leftCount,rightCount
+ if prefixArray2[j]:
+ flag=True
+ if i==j and prefixArray2[j]==1:
+ flag=False
+ if flag:
+ if prefixArray1[j]==0:
+ l+=1
+ if prefixArray2[j]==1:
+ r-=1
+ if l==r:
+ return True
+ prefixArray1[i]+=1
+ prefixArray2[i]-=1
+ if prefixArray1[i]==1:
+ leftCount+=1
+ if prefixArray2[i]==0:
+ rightCount-=1
+ return False
+

tests/test_swap_str.py

@@ -0,0 +1,21 @@
+from algorithms.strings import (
+ swap_str,
+)
+
+import unittest
+
+class Testswap_str(unittest.TestCase):
+ def test_swap_str1(self):
+ self.assertEqual(swap_str.checkSwapEquality('aabc','abcd'),True)
+
+ def test_swap_str2(self):
+ self.assertEqual(swap_str.checkSwapEquality('abcdef', 'fghijk'), True)
+
+ def test_swap_str3(self):
+ self.assertEqual(swap_str.checkSwapEquality('aab', 'c'), False)
+
+ def test_swap_str4(self):
+ self.assertEqual(swap_str.checkSwapEquality('mnopppq', 'xyzaa'), True)
+
+if __name__ == '__main__':
+ unittest.main()