# The most common substring

## Python 3.8, 756897 63 bytes

lambda s,n:max(l:=[s[j:j+n]for j in range(len(s))],key=l.count)


You can try it online! Increased byte count because, as @xnor kindly pointed out, Python's str.count doesn't count overlapping substrings... But then @xnor's reformulation of what I was doing allowed to slice a third of the bytes!

### How:

l:=[s[j:j+n]for j in range(len(s))]


This creates a list of all the substrings in s of size n, plus the suffixes of size n-1, n-2, ..., 1. Then we find the max on that list, with the numerical value being used to sort given by

l.count


That means that if a and b are from l, a > b if a shows up more times in l than b. This means the shorter suffixes are never the result of the max because they only show up once, and even if the correct-sized substrings only show up once, they are first in l so they come out instead of the short suffixes. This allows me to save some bytes in the range used, given that I don't have to prevent i+n from being larger than len(s).

# Python, 83 64 bytes

lambda s,n:max((s[i:i+n]for i in range(len(s)-n+1)),key=s.count)


Thanks to @mypetlion I saved a LOT of bytes :D

You can try it online with my very own incredible test case!

## 05AB1E, 5 bytes

ŒIù.M


Try it online or verify the smaller test cases or verify the larger test case (which is a bit slow).

Explanation:

Œ      # Push all substrings of the (implicit) input-string
Iù    # Only keep substrings of a length equal to the second input-integer
.M  # Only keep the most frequent item of the remaining substrings
# (after which it is output implicitly as result)


## Brachylog, 8 bytes

s₎ᶠọtᵒth


Try it online!

### Explanation

  ᶠ        Find all…
s          …substrings of <1st element of input>…
₎         …of length <2nd element of input>
ọ       Get the list of each substring with its number of occurrence
tᵒ     Order by the number of occurrence
t    Take the last one
h   Output the substring itself