Computer >> Computer tutorials >  >> Programming >> Python

Find the minimum number of preprocess moves required to make two strings equal in Python

Suppose we have two strings P and Q of same lengths with only lower case letters, we have to count the minimum number of pre-processing moves on string P are needed to make it equal to string Q after applying below operations −

  • Select any index i and swap characters pi and qi.

  • Select any index i and swap characters pi and pn – i – 1.

  • Select any index i and swap characters qi and qn – i – 1.

Note − The value of i in range (0 ≤ i < n)

In one move we can change a character in P with any other character of English alphabet.

So, if the input is like P = “pqprpqp”, Q = “qprpqpp”, then the output will be 4 as if we set P0 = ‘q’, P2 = ‘r’, P3 = ‘p’ and P4 = ‘q’ and P will be “qqrpqqp”. After that we can get equal strings by the following sequence of operations: swap(P1, Q1) and swap(P1, P5).

To solve this, we will follow these steps −

  • n := size of P

  • res := 0

  • for i in range 0 to n / 2, do

    • my_map := a new map

    • my_map[P[i]] := 1

    • if P[i] is same as P[n - i - 1], then

      • my_map[P[n - i - 1]] := my_map[P[n - i - 1]] + 1

    • if Q[i] is in my_map, then

      • my_map[Q[i]] := my_map[Q[i]] + 1

    • otherwise,

      • my_map[Q[i]] := 1

    • if Q[n - i - 1] is in my_map, then

      • my_map[Q[n - 1 - i]] := my_map[Q[n - 1 - i]] + 1

    • otherwise,

      • my_map[Q[n - 1 - i]] := 1

    • size := size of my_map

    • if size is same as 4, then

      • res := res + 2

    • otherwise when size is same as 3, then

      • res := res + 1 + (1 when (P[i] is same as P[n - i - 1]), otherwise 0)

    • otherwise when size is same as 2, then

      • res := res + my_map[P[i]] is not same as 2

  • if n mod 2 is same as 1 and P[n / 2] is not same as Q[n / 2], then

    • res := res + 1

  • return res

Example 

Let us see the following implementation to get better understanding −

def count_preprocess(P, Q):
   n = len(P)
   res = 0
   for i in range(n // 2):
      my_map = dict()
      my_map[P[i]] = 1
      if P[i] == P[n - i - 1]:
         my_map[P[n - i - 1]] += 1
      if Q[i] in my_map:
         my_map[Q[i]] += 1
      else:
         my_map[Q[i]] = 1
      if Q[n - i - 1] in my_map:
         my_map[Q[n - 1 - i]] += 1
      else:
         my_map[Q[n - 1 - i]] = 1
      size = len(my_map)
      if (size == 4):
         res += 2
      elif (size == 3):
         res += 1 + (P[i] == P[n - i - 1])
      elif (size == 2):
         res += my_map[P[i]] != 2
   if (n % 2 == 1 and P[n // 2] != Q[n // 2]):
      res += 1
   return res

A = "pqprpqp"
B = "qprpqpp"
print(count_preprocess(A, B))

Input

"pqprpqp", "qprpqpp"

Output

4