# Convert to a string that is repetition of a substring of k length

Given a string, find if it is possible to convert it to a string that is repetition of substring with k characters. To convert, we can replace one substring of length k with k characters.

Examples:

```Input: str = "bdac",  k = 2
Output: True
We can either replace "bd" with "ac" or
"ac" with "bd".

Input: str = "abcbedabcabc",  k = 3
Output: True
Replace "bed" with "abc" so that the
whole string becomes repetition of "abc".

Input: str = "bcacc", k = 3
Output: False
k doesn't divide string length i.e. 5%3 != 0

Input: str = "bcacbcac", k = 2
Output: False

Input: str = "bcdbcdabcedcbcd", k = 3
Output: False
```

This can be used in compression. If we have a string where complete string is repetition except one substring, then we can use this algorithm to compress the string.

## Recommended: Please solve it on “PRACTICE” first, before moving on to the solution.

One observation is, length of string must be a multiple of k as we can replace only one substring.
The idea is declare a map mp which maps strings of length k to an integer denoting its count. So, if there are only two different sub-strings of length k in the map container and count of one of the sub-string is 1 then answer is true. Otherwise answer is false.

## C++

 `// C++ program to check if a string can be converted to ` `// a string that has repeated substrings of length k. ` `#include ` `using` `namespace` `std; ` ` `  `// Returns true if str can be coverted to a string ` `// with k repeated substrings after replacing k ` `// characters. ` `bool` `checkString(string str, ``long` `k) ` `{ ` `    ``// Length of string must be a multiple of k ` `    ``int` `n = str.length(); ` `    ``if` `(n%k != 0) ` `        ``return` `false``; ` ` `  `    ``// Map to store strings of length k and their counts ` `    ``unordered_map mp; ` `    ``for` `(``int` `i=0; isecond == (n/k - 1)) || ` `                    ``mp.begin()->second == 1) ` `       ``return` `true``; ` ` `  `    ``return` `false``; ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` `    ``checkString(``"abababcd"``, 2)? cout << ``"Yes"` `: ` `                                ``cout << ``"No"``; ` `    ``return` `0; ` `} `

## Java

 `// Java program to check if a string  ` `// can be converted to a string that has ` `// repeated substrings of length k.  ` `import` `java.util.HashMap; ` `import` `java.util.Iterator; ` ` `  `class` `GFG  ` `{ ` ` `  `    ``// Returns true if str can be coverted ` `    ``// to a string with k repeated substrings  ` `    ``// after replacing k characters. ` `    ``static` `boolean` `checkString(String str, ``int` `k)  ` `    ``{ ` ` `  `        ``// Length of string must be ` `        ``// a multiple of k ` `        ``int` `n = str.length(); ` `        ``if` `(n % k != ``0``) ` `            ``return` `false``; ` ` `  `        ``// Map to store strings of  ` `        ``// length k and their counts ` `        ``HashMap mp = ``new` `HashMap<>(); ` `        ``try`  `        ``{ ` `            ``for` `(``int` `i = ``0``; i < n; i += k) ` `                ``mp.put(str.substring(i, k),  ` `                ``mp.get(str.substring(i, k)) == ``null` `? ``1` `:  ` `                ``mp.get(str.substring(i, k)) + ``1``); ` `        ``} ``catch` `(Exception e) {    } ` ` `  `        ``// If string is already a repition  ` `        ``// of k substrings, return true. ` `        ``if` `(mp.size() == ``1``) ` `            ``return` `true``; ` ` `  `        ``// If number of distinct substrings is not 2, ` `        ``// then not possible to replace a string. ` `        ``if` `(mp.size() != ``2``) ` `            ``return` `false``; ` ` `  `        ``HashMap.Entry entry = mp.entrySet().iterator().next(); ` ` `  `        ``// One of the two distinct must appear  ` `        ``// exactly once. Either the first entry  ` `        ``// appears once, or it appears n/k-1 times ` `        ``// to make other substring appear once. ` `        ``if` `(entry.getValue() == (n / k - ``1``) ||  ` `            ``entry.getValue() == ``1``) ` `            ``return` `true``; ` ` `  `        ``return` `false``; ` `    ``} ` ` `  `    ``// Driver code ` `    ``public` `static` `void` `main(String[] args)  ` `    ``{ ` `        ``if` `(checkString(``"abababcd"``, ``2``)) ` `            ``System.out.println(``"Yes"``); ` `        ``else` `            ``System.out.println(``"No"``); ` `    ``} ` `} ` ` `  `// This code is contributed by ` `// sanjeev2552 `

## Python3

 `# Python3 program to check if a can be converted to ` `# a that has repeated subs of length k. ` ` `  `# Returns True if S can be coverted to a  ` `# with k repeated subs after replacing k ` `# characters. ` `def` `check( S, k): ` `     `  `    ``# Length of must be a multiple of k ` `    ``n ``=` `len``(S) ` `     `  `    ``if` `(n ``%` `k !``=` `0``): ` `        ``return` `False` ` `  `    ``# Map to store s of length k and their counts ` `    ``mp ``=`  `{} ` `    ``for` `i ``in` `range``(``0``, n, k): ` `        ``mp[S[i:k]] ``=` `mp.get(S[i:k], ``0``) ``+` `1` ` `  `    ``# If is already a repition of k subs, ` `    ``# return True. ` `    ``if` `(``len``(mp) ``=``=` `1``): ` `        ``return` `True` ` `  `    ``# If number of distinct subs is not 2, then ` `    ``# not possible to replace a . ` `    ``if` `(``len``(mp) !``=` `2``): ` `        ``return` `False` ` `  `    ``# One of the two distinct must appear exactly once. ` `    ``# Either the first entry appears once, or it appears ` `    ``# n/k-1 times to make other sub appear once. ` `    ``for` `i ``in` `mp: ` `        ``if` `i ``=``=` `(n``/``/``k ``-` `1``) ``or` `mp[i] ``=``=` `1``: ` `            ``return` `True` ` `  `    ``return` `False` ` `  `# Driver code ` ` `  `if` `check(``"abababcd"``, ``2``): ` `    ``print``(``"Yes"``) ` `else``: ` `    ``print``(``"No"``) ` `     `  `# This code is contributed by mohit kumar 29     `

## C#

 `// C# program to check if a string  ` `// can be converted to a string that has ` `// repeated substrings of length k. ` `using` `System; ` `using` `System.Collections.Generic; ` ` `  `class` `GFG  ` `{ ` ` `  `    ``// Returns true if str can be coverted ` `    ``// to a string with k repeated substrings  ` `    ``// after replacing k characters. ` `    ``static` `bool` `checkString(String str, ``int` `k)  ` `    ``{ ` ` `  `        ``// Length of string must be ` `        ``// a multiple of k ` `        ``int` `n = str.Length; ` `        ``if` `(n % k != 0) ` `            ``return` `false``; ` ` `  `        ``// Map to store strings of  ` `        ``// length k and their counts ` `        ``Dictionary mp = ``new` `Dictionary(); ` ` `  `        ``for` `(``int` `i = 0; i < n; i += k) ` `        ``{ ` `            ``if``(!mp.ContainsKey(str.Substring(i, k))) ` `                ``mp.Add(str.Substring(i, k), 1); ` `            ``else` `                ``mp[str.Substring(i, k)] = mp[str.Substring(i, k)] + 1; ` `        ``} ` ` `  `        ``// If string is already a repition  ` `        ``// of k substrings, return true. ` `        ``if` `(mp.Count == 1) ` `            ``return` `true``; ` ` `  `        ``// If number of distinct substrings is not 2, ` `        ``// then not possible to replace a string. ` `        ``if` `(mp.Count != 2) ` `            ``return` `false``; ` ` `  `        ``foreach``(KeyValuePair entry ``in` `mp) ` `        ``{ ` ` `  `            ``// One of the two distinct must appear  ` `            ``// exactly once. Either the first entry  ` `            ``// appears once, or it appears n/k-1 times ` `            ``// to make other substring appear once. ` `            ``if` `(entry.Value == (n / k - 1) ||  ` `                ``entry.Value == 1) ` `                ``return` `true``; ` `        ``} ` `        ``return` `false``; ` `    ``} ` ` `  `    ``// Driver code ` `    ``public` `static` `void` `Main(String[] args)  ` `    ``{ ` `        ``if` `(checkString(``"abababcd"``, 2)) ` `            ``Console.WriteLine(``"Yes"``); ` `        ``else` `            ``Console.WriteLine(``"No"``); ` `    ``} ` `} ` ` `  `// This code is contributed by Princi Singh `

Output:

`Yes`

This article is contributed by Himanshu Gupta(Bagri). 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.

Don’t stop now and take your learning to the next level. Learn all the important concepts of Data Structures and Algorithms with the help of the most trusted course: DSA Self Paced. Become industry ready at a student-friendly price.

My Personal Notes arrow_drop_up

Article Tags :
Practice Tags :

Be the First to upvote.

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.