Similar to the [previous kata](https://www.codewars.com/kata/string-subpattern-recognition-ii/), but this time you need to operate with shuffled strings to identify if they are composed repeating a subpattern

Since there is no deterministic way to tell which pattern was really the original one among all the possible permutations of a fitting subpattern, return a subpattern with sorted characters, otherwise return the base string with sorted characters (you might consider this case as an edge case, with the subpattern being repeated only once and thus equalling the original input string).

For example:

```python
has_subpattern("a") == "a"; #no repeated pattern, just one character
has_subpattern("aaaa") == "a" #just one character repeated
has_subpattern("abcd") == "abcd" #base pattern equals the string itself, no repetitions
has_subpattern("babababababababa") == "ab" #remember to return the base string sorted"
has_subpattern("bbabbaaabbaaaabb") == "ab" #same as above, just shuffled
```

If you liked it, go for either the [previous kata](https://www.codewars.com/kata/string-subpattern-recognition-ii/) or the [next kata](https://www.codewars.com/kata/string-subpattern-recognition-iv/) of the series!

Difficulty: EASY
Tags: String algorithms

Fundamentals

Starter code:
def has_subpattern(string):
	

Solutions:
from collections import Counter
from functools import reduce
from fractions import gcd

def has_subpattern(s):
	c = Counter(s)
	m = reduce(gcd, c.values())
	return ''.join(sorted((k * (v // m) for (k, v) in c.items())))


from collections import Counter
from functools import reduce
from math import gcd

def has_subpattern(string):
	count = Counter(string)
	n = reduce(gcd, count.values())
	return ''.join(sorted((c * (i // n) for (c, i) in count.items())))


from functools import reduce as R
from collections import Counter as C
from math import gcd as G

def has_subpattern(s):
	s = C(s)
	k = R(G, set(s.values()))
	li = [i * (j // k) for (i, j) in s.items()]
	return ''.join(sorted(li))


from collections import Counter as C
from functools import reduce as R
from fractions import gcd

def has_subpattern(s):
	c = C(s)
	a = R(gcd, c.values())
	return ''.join(sorted([x * int(c[x] / a) for x in c]))


from collections import Counter
from functools import reduce
from math import gcd

def has_subpattern(string):
	c = Counter(string)
	m = reduce(gcd, c.values())
	for key in c:
		c[key] //= m
	return ''.join(sorted(c.elements()))


from collections import Counter
from functools import reduce
gcd = lambda a, b: gcd(b, a % b) if b else a
has_subpattern = lambda s: (lambda r: (lambda g: ''.join((k * (v // g) for (k, v) in sorted(r.items()))))(reduce(gcd, r.values())))(Counter(s))


from collections import Counter
from math import gcd
from functools import reduce

def has_subpattern(string):
	cnt = Counter(string)
	v = reduce(gcd, cnt.values())
	return ''.join(sorted((k * (n // v) for (k, n) in cnt.items())))


from collections import Counter
from functools import reduce
from math import gcd

def has_subpattern(string):
	if len(string) < 2:
		return string
	c = Counter(string)
	x = reduce(gcd, c.values())
	if x == 1:
		return ''.join(sorted(string))
	return ''.join((k * (c[k] // x) for k in sorted(c.keys())))


from collections import Counter
from functools import reduce
from math import gcd

def has_subpattern(string):
	chars_frequency = Counter(string)
	greatercd = reduce(gcd, chars_frequency.values())
	charslist = sorted(chars_frequency.items())
	pattern = ''
	for (char, frequency) in charslist:
		pattern += char * (frequency // greatercd)
	return pattern


from math import gcd
from functools import reduce

def has_subpattern(s):
	d = {k: s.count(k) for k in set(s)}
	g = reduce(gcd, d.values())
	return ''.join(sorted((k * (v // g) for (k, v) in d.items())))