Skip to content
Related Articles
Minimum move to end operations to make all strings equal
• Difficulty Level : Medium
• Last Updated : 03 May, 2021

Given n strings that are permutations of each other. We need to make all strings same with an operation that takes front character of any string and moves it to the end.
Examples:

```Input : n = 2
arr[] = {"molzv", "lzvmo"}
Output : 2
Explanation: In first string, we remove
first element("m") from first string and
append it end. Then we move second character
of first string and move it to end. So after
2 operations, both strings become same.

Input : n = 3
arr[] = {"kc", "kc", "kc"}
Output : 0
Explanation: already all strings are equal.```

The move to end operation is basically left rotation. We use the approach discussed in check if strings are rotations of each other or not to count number of move to front operations required to make two strings same. We one by one consider every string as the target string. We count rotations required to make all other strings same as current target and finally return minimum of all counts.
Below is the implementation of above approach.

## C++

 `// CPP program to make all strings same using``// move to end operations.``#include ``using` `namespace` `std;` `// Returns minimum number of moves to end``// operations to make all strings same.``int` `minimunMoves(string arr[], ``int` `n)``{``    ``int` `ans = INT_MAX;``    ``for` `(``int` `i = 0; i < n; i++)``    ``{``        ``int` `curr_count = 0; ` `        ``// Consider s[i] as target string and``        ``// count rotations required to make``        ``// all other strings same as str[i].``        ``for` `(``int` `j = 0; j < n; j++) {` `            ``string tmp = arr[j] + arr[j];` `            ``// find function returns the index where we``            ``// found arr[i] which is actually count of``            ``// move-to-front operations.``            ``int` `index = tmp.find(arr[i]);` `            ``// If any two strings are not rotations of``            ``// each other, we can't make them same. ``            ``if` `(index == string::npos)``                ``return` `-1;` `            ``curr_count += index;``        ``}` `        ``ans = min(curr_count, ans);``    ``}` `    ``return` `ans;``}` `// driver code for above function.``int` `main()``{``    ``string arr[] = {``"xzzwo"``, ``"zwoxz"``, ``"zzwox"``, ``"xzzwo"``}; ``    ``int` `n = ``sizeof``(arr)/``sizeof``(arr);``    ``cout << minimunMoves(arr, n);``    ``return` `0;``}`

## Java

 `// Java program to make all``// strings same using move``// to end operations.``import` `java.util.*;``class` `GFG``{` `// Returns minimum number of``// moves to end operations``// to make all strings same.``static` `int` `minimunMoves(String arr[], ``int` `n)``{``    ``int` `ans = Integer.MAX_VALUE;``    ``for` `(``int` `i = ``0``; i < n; i++)``    ``{``        ``int` `curr_count = ``0``;` `        ``// Consider s[i] as target``        ``// string and count rotations``        ``// required to make all other``        ``// strings same as str[i].``        ``String tmp = ``""``;``        ``for` `(``int` `j = ``0``; j < n; j++)``        ``{``            ``tmp = arr[j] + arr[j];` `            ``// find function returns the``            ``// index where we found arr[i]``            ``// which is actually count of``            ``// move-to-front operations.``            ``int` `index = tmp.indexOf(arr[i]);` `            ``// If any two strings are not``            ``// rotations of each other,``            ``// we can't make them same.``            ``if` `(index == arr[i].length())``                ``return` `-``1``;``                ` `            ``curr_count += index;``        ``}` `        ``ans = Math.min(curr_count, ans);``    ``}` `    ``return` `ans;``}` `// Driver code``public` `static` `void` `main(String args[])``{``    ``String arr[] = {``"xzzwo"``, ``"zwoxz"``,``                    ``"zzwox"``, ``"xzzwo"``};``    ``int` `n = arr.length;``    ``System.out.println(minimunMoves(arr, n));``}``}` `// This code is contributed``// by Kirti_Mangal`

## Python 3

 `# Python 3 program to make all strings``# same using move to end operations.``import` `sys` `# Returns minimum number of moves to end``# operations to make all strings same.``def` `minimunMoves(arr, n):` `    ``ans ``=` `sys.maxsize``    ``for` `i ``in` `range``(n):` `        ``curr_count ``=` `0` `        ``# Consider s[i] as target string and``        ``# count rotations required to make``        ``# all other strings same as str[i].``        ``for` `j ``in` `range``(n):` `            ``tmp ``=` `arr[j] ``+` `arr[j]` `            ``# find function returns the index where``            ``# we found arr[i] which is actually``            ``# count of move-to-front operations.``            ``index ``=` `tmp.find(arr[i])` `            ``# If any two strings are not rotations of``            ``# each other, we can't make them same.``            ``if` `(index ``=``=` `len``(arr[i])):``                ``return` `-``1` `            ``curr_count ``+``=` `index` `        ``ans ``=` `min``(curr_count, ans)` `    ``return` `ans` `# Driver Code``if` `__name__ ``=``=` `"__main__"``:``    ` `    ``arr ``=` `[``"xzzwo"``, ``"zwoxz"``, ``"zzwox"``, ``"xzzwo"``]``    ``n ``=` `len``(arr)``    ``print``( minimunMoves(arr, n))` `# This code is contributed by ita_c`

## C#

 `using` `System;` `// C# program to make all``// strings same using move``// to end operations.``public` `class` `GFG``{` `// Returns minimum number of``// moves to end operations``// to make all strings same.``public`  `static` `int` `minimunMoves(``string``[] arr, ``int` `n)``{``    ``int` `ans = ``int``.MaxValue;``    ``for` `(``int` `i = 0; i < n; i++)``    ``{``        ``int` `curr_count = 0;` `        ``// Consider s[i] as target``        ``// string and count rotations``        ``// required to make all other``        ``// strings same as str[i].``        ``string` `tmp = ``""``;``        ``for` `(``int` `j = 0; j < n; j++)``        ``{``            ``tmp = arr[j] + arr[j];` `            ``// find function returns the``            ``// index where we found arr[i]``            ``// which is actually count of``            ``// move-to-front operations.``            ``int` `index = tmp.IndexOf(arr[i], StringComparison.Ordinal);` `            ``// If any two strings are not``            ``// rotations of each other,``            ``// we can't make them same.``            ``if` `(index == arr[i].Length)``            ``{``                ``return` `-1;``            ``}` `            ``curr_count += index;``        ``}` `        ``ans = Math.Min(curr_count, ans);``    ``}` `    ``return` `ans;``}` `// Driver code``public` `static` `void` `Main(``string``[] args)``{``    ``string``[] arr = ``new` `string``[] {``"xzzwo"``, ``"zwoxz"``, ``"zzwox"``, ``"xzzwo"``};``    ``int` `n = arr.Length;``    ``Console.WriteLine(minimunMoves(arr, n));``}``}` `// This code is contributed by Shrikant13`

## Javascript

 ``

Output:

`5`

This article is contributed by Pawan Asipu. If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.
Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with industry experts, please refer DSA Live Classes

My Personal Notes arrow_drop_up