Given two binary strings **s** and **t**. The task is to rearrange the string **s** in such a way that the occurrence of string **t** as a sub-string in **s** is maximum.

**Examples:**

Input:s = “101101”, t = “110”

Output:110110

Input:s = “10”, t = “11100”

Output:10

Input:s = “11000100”, t = “101”

Output:10101000

**Approach:** If we can not make any occurrence of string **t** in string **s** then output any permutation of **s**. Otherwise, start the rearranged string with **t**. Now we will make the next occurrence of string **t** in string **s** as left as possible in order maximize the count of occurrence. To achieve this we will find the largest suffix of string **t** that matches the prefix of string **t**

of the same length. It can be found by Prefix Function, Z-Function or Hashes.

Below is the implementation of the above approach:

`# Python3 implementation of the approach ` `from` `collections ` `import` `defaultdict ` ` ` `# Function to return the length of maximum ` `# proper suffix which is also proper prefix ` `def` `Prefix_Array(t): ` ` ` `m ` `=` `len` `(t) ` ` ` `arr ` `=` `[` `-` `1` `]` `*` `m ` ` ` `k ` `=` `-` `1` ` ` `for` `i ` `in` `range` `(` `1` `, m): ` ` ` `while` `k>` `-` `1` `and` `t[k ` `+` `1` `]!` `=` `t[i]: ` ` ` `k ` `=` `arr[k] ` ` ` `if` `t[k ` `+` `1` `]` `=` `=` `t[i]: ` ` ` `k` `+` `=` `1` ` ` `arr[i]` `=` `k ` ` ` `return` `arr[` `-` `1` `] ` ` ` `# Function to return the rearranged string ` `def` `Rearranged(ds, dt): ` ` ` `check ` `=` `Prefix_Array(t) ` ` ` ` ` `# If there is no proper suffix which is ` ` ` `# also a proper prefix ` ` ` `if` `check ` `=` `=` `-` `1` `: ` ` ` `if` `ds[` `'1'` `]<dt[` `'1'` `] ` `or` `ds[` `'0'` `]<dt[` `'0'` `]: ` ` ` `return` `s ` ` ` ` ` `# If count of 1's in string t is 0 ` ` ` `if` `dt[` `'1'` `]` `=` `=` `0` `and` `ds[` `'0'` `]!` `=` `0` `: ` ` ` `n ` `=` `ds[` `'0'` `]` `/` `/` `dt[` `'0'` `] ` ` ` `temp ` `=` `t ` `*` `n ` ` ` `ds[` `'0'` `]` `-` `=` `n ` `*` `dt[` `'0'` `] ` ` ` `while` `ds[` `'1'` `]>` `0` `: ` ` ` `temp` `+` `=` `'1'` ` ` `ds[` `'1'` `]` `-` `=` `1` ` ` `while` `ds[` `'0'` `]>` `0` `: ` ` ` `temp` `+` `=` `'0'` ` ` `ds[` `'0'` `]` `-` `=` `1` ` ` ` ` `# Return the rearranged string ` ` ` `return` `temp ` ` ` ` ` `# If count of 0's in string t is 0 ` ` ` `if` `dt[` `'0'` `]` `=` `=` `0` `and` `ds[` `'1'` `]!` `=` `0` `: ` ` ` `n ` `=` `ds[` `'1'` `]` `/` `/` `dt[` `'1'` `] ` ` ` `temp ` `=` `t ` `*` `n ` ` ` `ds[` `'1'` `]` `-` `=` `n ` `*` `dt[` `'1'` `] ` ` ` `while` `ds[` `'1'` `]>` `0` `: ` ` ` `temp` `+` `=` `'1'` ` ` `ds[` `'1'` `]` `-` `=` `1` ` ` `while` `ds[` `'0'` `]>` `0` `: ` ` ` `temp` `+` `=` `'0'` ` ` `ds[` `'0'` `]` `-` `=` `1` ` ` ` ` `# Return the rearranged string ` ` ` `return` `temp ` ` ` ` ` `# If both 1's and 0's are present in ` ` ` `# string t ` ` ` `m1 ` `=` `ds[` `'1'` `]` `/` `/` `dt[` `'1'` `] ` ` ` `m2 ` `=` `ds[` `'0'` `]` `/` `/` `dt[` `'0'` `] ` ` ` `n ` `=` `min` `(m1, m2) ` ` ` `temp ` `=` `t ` `*` `n ` ` ` `ds[` `'1'` `]` `-` `=` `n ` `*` `dt[` `'1'` `] ` ` ` `ds[` `'0'` `]` `-` `=` `n ` `*` `dt[` `'0'` `] ` ` ` `while` `ds[` `'1'` `]>` `0` `: ` ` ` `temp` `+` `=` `'1'` ` ` `ds[` `'1'` `]` `-` `=` `1` ` ` `while` `ds[` `'0'` `]>` `0` `: ` ` ` `temp` `+` `=` `'0'` ` ` `ds[` `'0'` `]` `-` `=` `1` ` ` `return` `temp ` ` ` ` ` `# If there is a suffix which is ` ` ` `# also a prefix in string t ` ` ` `else` `: ` ` ` `if` `ds[` `'1'` `]<dt[` `'1'` `] ` `or` `ds[` `'0'` `]<dt[` `'0'` `]: ` ` ` `return` `s ` ` ` ` ` `# Append the remaining string each time ` ` ` `r ` `=` `t[check ` `+` `1` `:] ` ` ` `dr ` `=` `defaultdict(` `int` `) ` ` ` `for` `v ` `in` `r: ` ` ` `dr[v]` `+` `=` `1` ` ` `temp ` `=` `t ` ` ` `ds[` `'1'` `]` `-` `=` `dt[` `'1'` `] ` ` ` `ds[` `'0'` `]` `-` `=` `dt[` `'0'` `] ` ` ` ` ` `# If we can't form the string t ` ` ` `# by the remaining 0's and 1's ` ` ` `if` `ds[` `'1'` `]<dr[` `'1'` `] ` `or` `ds[` `'0'` `]<dr[` `'0'` `]: ` ` ` `while` `ds[` `'1'` `]>` `0` `: ` ` ` `temp` `+` `=` `'1'` ` ` `ds[` `'1'` `]` `-` `=` `1` ` ` `while` `ds[` `'0'` `]>` `0` `: ` ` ` `temp` `+` `=` `'0'` ` ` `ds[` `'0'` `]` `-` `=` `1` ` ` `return` `temp ` ` ` ` ` `# If count of 1's in string r is 0 ` ` ` `if` `dr[` `'1'` `]` `=` `=` `0` `and` `ds[` `'0'` `]!` `=` `0` `: ` ` ` `n ` `=` `ds[` `'0'` `]` `/` `/` `dr[` `'0'` `] ` ` ` `temp` `+` `=` `r ` `*` `n ` ` ` `ds[` `'0'` `]` `-` `=` `n ` `*` `dr[` `'0'` `] ` ` ` `while` `ds[` `'1'` `]>` `0` `: ` ` ` `temp` `+` `=` `'1'` ` ` `ds[` `'1'` `]` `-` `=` `1` ` ` `while` `ds[` `'0'` `]>` `0` `: ` ` ` `temp` `+` `=` `'0'` ` ` `ds[` `'0'` `]` `-` `=` `1` ` ` `return` `temp ` ` ` ` ` `# If count of 0's in string r is 0 ` ` ` `if` `dr[` `'0'` `]` `=` `=` `0` `and` `ds[` `'1'` `]!` `=` `0` `: ` ` ` `n ` `=` `ds[` `'1'` `]` `/` `/` `dr[` `'1'` `] ` ` ` `temp` `+` `=` `r ` `*` `n ` ` ` `ds[` `'1'` `]` `-` `=` `n ` `*` `dr[` `'1'` `] ` ` ` `while` `ds[` `'1'` `]>` `0` `: ` ` ` `temp` `+` `=` `'1'` ` ` `ds[` `'1'` `]` `-` `=` `1` ` ` `while` `ds[` `'0'` `]>` `0` `: ` ` ` `temp` `+` `=` `'0'` ` ` `ds[` `'0'` `]` `-` `=` `1` ` ` `return` `temp ` ` ` ` ` `# If string r have both 0's and 1's ` ` ` `m1 ` `=` `ds[` `'1'` `]` `/` `/` `dr[` `'1'` `] ` ` ` `m2 ` `=` `ds[` `'0'` `]` `/` `/` `dr[` `'0'` `] ` ` ` `n ` `=` `min` `(m1, m2) ` ` ` `temp` `+` `=` `r ` `*` `n ` ` ` `ds[` `'1'` `]` `-` `=` `n ` `*` `dr[` `'1'` `] ` ` ` `ds[` `'0'` `]` `-` `=` `n ` `*` `dr[` `'0'` `] ` ` ` `while` `ds[` `'1'` `]>` `0` `: ` ` ` `temp` `+` `=` `'1'` ` ` `ds[` `'1'` `]` `-` `=` `1` ` ` `while` `ds[` `'0'` `]>` `0` `: ` ` ` `temp` `+` `=` `'0'` ` ` `ds[` `'0'` `]` `-` `=` `1` ` ` `return` `temp ` ` ` `# Driver code ` `if` `__name__` `=` `=` `"__main__"` `: ` ` ` `s ` `=` `"10101000"` ` ` `t ` `=` `"101"` ` ` ` ` `# Count of 0's and 1's in string s ` ` ` `ds ` `=` `defaultdict(` `int` `) ` ` ` ` ` `# Count of 0's and 1's in string t ` ` ` `dt ` `=` `defaultdict(` `int` `) ` ` ` `for` `i ` `in` `s: ` ` ` `ds[i]` `=` `ds[i]` `+` `1` ` ` `for` `i ` `in` `t: ` ` ` `dt[i]` `=` `dt[i]` `+` `1` ` ` `print` `(Rearranged(ds, dt)) ` |

*chevron_right*

*filter_none*

**Output:**

10101000

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.

## Recommended Posts:

- Group multiple occurrence of array elements ordered by first occurrence
- Rearrange given binary strings to maximize their Bitwise XOR value
- Rearrange the string to maximize the number of palindromic substrings
- Program to count occurrence of a given character in a string
- Count occurrence of a given character in a string using Stream API in Java
- Python | Replacing Nth occurrence of multiple characters in a String with the given character
- Find the Nth occurrence of a character in the given String
- Remove the first and last occurrence of a given Character from a String
- Find the occurrence of the given binary pattern in the binary representation of the array elements
- Modify given array by incrementing first occurrence of every element by K
- Print the Vowels in the Order of their occurrence in the given Matrix
- Rearrange the given string such that all prime multiple indexes have same character
- Rearrange a string according to the given indices
- Generate two output strings depending upon occurrence of character in input string.
- Generate two output strings depending upon occurrence of character in input string in Python
- Find indices of all occurrence of one string in other
- Minimize the length of string by removing occurrence of only one character
- Count maximum occurrence of subsequence in string such that indices in subsequence is in A.P.
- Queries to insert, delete one occurrence of a number and print the least and most frequent element
- Print the last occurrence of elements in array in relative order

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.