Finding a sequence of characters in string

itertools to the rescue :)

>>> import itertools
>>> val = 5
>>> x
'jhg**11111**jjhgj**11111**klhhkjh111ljhjkh1111'
>>> [y[0]*val for y in itertools.groupby(x) if len(list(y[1])) == val]
['11111', '11111']

Edit: naming well

>>> [char*val for char,grouper in itertools.groupby(x) if len(list(grouper)) == val]
['11111', '11111']

Or the more memory efficient oneliner suggested by @Chris_Rands

>>> [k*val for k, g in itertools.groupby(x) if sum(1 for _ in g) == val]

Or if you are fine with using regex, makes your code a lot cleaner:

[row[0] for row in re.findall(r'((.)\2{4,})', s)]

regex101 - example

The original answer (below) is for a different problem (identifying repeated patterns of n characters in the string). Here is one possible one liner to solve the problem:

x = "jhg**11111**jjhgj**11111**klhhkjh111ljhjkh1111"
n = 5
res = [x[i:i + n] for i, c in enumerate(x) if x[i:i + n] == c * n]
print(res)
# ['11111', '11111']

Original (wrong) answer

Using Counter:

from collections import Counter

x = "jhg**11111**jjhgj**11111**klhhkjh111ljhjkh1111"
n = 5
c = Counter(x[i:i + n] for i in range(len(x) - n + 1))
for k, v in c.items():
    if v > 1:
        print(*([k] * v), sep='\n')

Output:

**111
**111
*1111
*1111
11111
11111
1111*
1111*
111**
111**

Very ugly solution :-)

x = "jhg**11111**jjhgj**11111**klhhkjh22222jhjkh1111"
for c, i in enumerate(x):
    if i == x[c+1:c+2] and i == x[c+2:c+3] and i == x[c+3:c+4] and i == x[c+4:c+5]:
        print(x[c:c+5])

try this:

x = "jhg**11111**jjhgj**11111**klhhkjh111ljhjkh1111"

seq_length = 5

for item in set(x):
    if seq_length*item in x:
        for i in range(x.count(seq_length*item)):
            print(seq_length*item)

it works by leveraging set() to easily construct the sequence you're looking for and then searches for it in the text

outputs your desired output:

11111
11111

Let's change a little your source string:

x = "jhg**11111**jjhgj**22222**klhhkjh33333jhjkh44444"

The regex should be:

pat = r'(.)\1{4}'

Here you have a capturing group (a single char) and a backreference to it (4 times), so totally the same char must occur 5 times.

One variant to print the result, although less intuitive is:

res = re.findall(pat, x)
print(res)

But the above code prints:

['1', '2', '3', '4']

i.e. a list, where each position is only the capturing group (in our case the first char), not the whole match.

So I propose also the second variant, with finditer and printing both start position and the whole match:

for match in re.finditer(pat, x):
    print('{:2d}: {}'.format(match.start(), match.group()))

For the above data the result is:

 5: 11111
19: 22222
33: 33333
43: 44444