[Question]
  [
If an integer has a digit/sequence of digits in it which repeats continuously (You will understand why I said "continuously") 5 or more times, we call It "Boring".
For example, `11111` is Boring, whereas `12345` is not.
# Instructions
Take an Integer as Input
Output a truthy value if the integer is boring, and a falsey value if the integer is not boring.
# Example
`11111`=>`true` or `1` (1 repeats 5 times)
`12345`=>`false` or `0`
`1112111`=>`false` or `0`
`4242424242`=>`true` or `1` (42 repeats 5 times)
`-11111`=>`true` or `1`
`3452514263534543543543543543876514264527473275`=>`true` or `1` (543 repeats 5 times)
If you use other types of "truth" and "false", specify it.
# Rules
Basic [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'") rules apply.
Good luck!
  
[Answer]
# [Retina](https://github.com/m-ender/retina), 9 bytes
```
(.+)\1{4}
```
[Verify all testcases!](http://retina.tryitonline.net/#code=JWAoLispXDF7NH0&input=MTExMTEKMTIzNDUKMTExMjExMQo0MjQyNDI0MjQy) (slightly modified to run all testcases at once.)
[Answer]
# [05AB1E](http://github.com/Adriandmen/05AB1E), 8 bytes
Code:
```
Œv¹y5×åO
```
Explanation:
```
Œ         # Compute all substrings from the input.
 v        # For each substring.
   y5×    # Repeat the substring 5 times (42 × 5 = 4242424242).
  ¹   å   # Check if it's in the input string.
       O  # Sum up the result. Non-boring numbers should give 0.
```
**Truthy** is non-zero and **falsy** is zero. Uses the **CP-1252** encoding.
[Try it online!](http://05ab1e.tryitonline.net/#code=xZJ2wrl5NcOXw6VP&input=NDI0MjQyNDI0Mg)
[Answer]
# Java 8, 52 bytes
```
s->s.matches(".*(.+)\\1{4}.*")
```
Outgolfed [this Java 8 answer](https://codegolf.stackexchange.com/a/84750/52210) with a direct `String#matches`.
**Explanation:**
[Try it here.](https://tio.run/##jU9LbsIwEN3nFKOsbKpYsuOQSojeoGxYQheDcVtDYkfYICGUs6fDT2JVsGeksd5nnjd4wCJ01m/W28E0GCN8ovOnDMD5ZHffaCzMzk@AVQiNRQ@GzdPO@R@IfEJAT00VEyZnYAYepjDE4iOKFpP5tZHlYsTEG18u5Un3YpTzYZKRotuvGlLchIfg1tDS7pv74gv5de/8GJNtRdgn0RGSGs@8MCyX55PzS4h/WKrU1XOWlOoVN63u9ym1eC0fpVOV1GpcVjTq8rHe6/EFIkqt61LV94/0WT/8AQ)
```
s->              // Method with String parameter and boolean return-type
  s.matches(     //  Return whether the entire String matches the following regex:
    ".*          //   0 or more leading characters
     (.+)\\1{4}  //   group of 1 or more characters, repeated 5 times
     .*")        //   0 or more trailing characters
```
[Answer]
# Java 8, ~~73~~ 66 bytes:
```
L->java.util.regex.Pattern.compile("(.+)\\1{4}").matcher(L).find();
```
Hooray for Java 8 lambdas! Returns `true` if match is found and `false` otherwise.
[Try It Online! (Ideone)](http://ideone.com/bU1vbB)
[Answer]
## Lua, 35 Bytes
Well, I don't see how to do better with Lua's patterns! Takes a command-line argument as input and output `nil` for falsy cases, and the number repeated when truthy.
```
print((...):match("(%d+)%1%1%1%1"))
```
[Answer]
# JavaScript, 16 bytes
In node.js (60 bytes)
```
process.stdin.on('data',t=>console.log(/(.+)\1{4}/.test(t)))
```
Wasting a *ton* of bytes on input/output.
JavaScript ES6 (33 bytes)
```
alert(/(.+)\1{4}/.test(prompt()))
```
Again wasting bytes on input/output.
Preferably, as an anonymous function (22 bytes)
```
n=>/(.+)\1{4}/.test(n)
```
Or even shorter (**16 bytes**)
```
/(.+)\1{4}/.test
```
Thanks @BusinessCat for pointing out my mistakes.
[Answer]
# Python 3.5, ~~49~~ 43 bytes:
(*-6 bytes thanks to tips from [Martin Ender](https://codegolf.stackexchange.com/users/8478/martin-ender)!*)
```
import re;lambda u:re.search(r'(.+)\1{4}',u)
```
Uses a Regular Expression to match all repeating sequences of characters as long as they repeat continuously 5 or more times. Returns an `re` match object (such as `<_sre.SRE_Match object; span=(0, 10), match='4242424242'>`) if a match is found as a truthy value, and nothing or `None` as a falsey value. 
[Try It Online! (Ideone)](http://ideone.com/I41iPz)
[Answer]
## Perl, ~~17~~ 15 bytes
```
$_=/(.+)\1{4}/
```
+ the `p` flag.
(run with `perl -pe '$_=/(.+)\1{4}/'`)
Thanks to Dom Hasting for the `(.+)` instead of `(\d+)`.
Explanations if needed :
 `(.+)` will match any part of the number, and `\1{4}$` searches if it is repeated 4 times consecutives.
[Answer]
# [Husk](https://github.com/barbuz/Husk), ~~13~~ 11 bytes
```
§ṁ€ȯm*5tQda
```
[Try it online!](https://tio.run/##yygtzv7//9DyhzsbHzWtObE@V8u0JDAl8f///7qGIAAA "Husk – Try It Online")
similar to 05AB1E.
-2 bytes from Dominic Van Essen and Jo King.
[Answer]
## SABDT, 41 bytes
White Space-less:
```
if($.r("(.+)\1{4})"=""){pr"0";}el{pr"1";}
```
Prettified:
```
if( $.r( "(.+)\1{4}" ) = "" ){
    pr "0";
} el {
    pr "1";
}
```
Answer brought to you partly by the brilliant person who came up the regex "(.+)\1{4}"
[Answer]
# [Python 3](https://docs.python.org/3/) without regex, 66 bytes
```
lambda s:any(s[j:i]*5in s for i in range(len(s))for j in range(i))
```
[Try it online!](https://tio.run/##TY3PDsIgDIdfpcdi8DD@DEPik8wdMA5lmd0CXPb0CBqjbQ@/fl@Tbnt@rCSLP1/K4p7Xm4NkHe2YhtmG8aADQQK/RghQY3R0n3CZCBNjjc4/GhgrDVFDQ9eKd0IqzWsSbVPi2/z48dUK3SnRS12jkv9zMv1b1ROjjBRGjxa2GCijx5QjEqsfXw "Python 3 – Try It Online")
[Answer]
## C# - 93 38 bytes
```
s=>new Regex(@"(.+)\1{4}").IsMatch(s);
```
Takes a string, returns an integer.
Thanks to [aloisdg](https://codegolf.stackexchange.com/users/15214/aloisdg) for saving a lot of bytes!
[Answer]
# [Pyth](https://github.com/isaacg1/pyth), ~~9~~ 8 bytes
1 byte thanks to Maltysen.
```
~~sm}\*5dQ.:~~
f}*5TQ.:
```
Truthy value is a non-empty array.
Falsey value is `[]` (empty array).
[Test suite.](http://pyth.herokuapp.com/?code=f%7D%2a5TQ.%3A&test_suite=1&test_suite_input=%2211111%22%0A%2212345%22%0A%221112111%22%0A%224242424242%22&debug=0)
```
f}*5TQ.:   input as a string stored in Q
f}*5TQ.:Q  implicit arguments
        Q  input
      .:   all substrings of.
f   T      filter for this condition, keep those returning true:
  *5           repeat five times
 }   Q         in Q? (True/False)
```
[Answer]
# Mathematica, ~~46~~ ~~40~~ 36 bytes
```
b=a__;StringContainsQ[b~~b~~b~~b~~b]
```
Function. Takes a string as input and outputs `True` or `False`. Tests strings against the expression `a__~~a__~~a__~~a__~~a__`, which represents the same character sequence repeated 5 times. For reference, the shortest solution using a regex is 45 bytes long:
```
StringContainsQ@RegularExpression@"(.+)\1{4}"
```
*curse you RegularExpression!*
[Answer]
# PHP, ~~37~~ 33 bytes
thanks to NoOneIsHere, I forgot about `<?=`
program for PHP<5.4, prints `1` for boring numbers, `0` else
```
<?=preg_match('/(.+)\1{4}/U',$n);
```
usage:
* set `register_globals=1` in `php.ini` for php-cgi  
then call `php-cgi <filename> n=<number>;echo""`
* for PHP>=5.4, replace `$n` with `$_GET[n]`
**non-regexp solution, ~~152~~ ~~147~~ 140 bytes**
```
<?for($e=$n+1;--$e;)for($f=$e;$f--;)for($a=str_split(substr($n,$f),$e),$k=$c='';strlen($v=array_pop($a));)$c-$v?$k=0&$c=$v:($k++<3?:die(1));
```
* returns exit code 1 for boring numbers, 0 else  
replace `die(1)` with `die(print 1)` and append `echo 0;` to print instead
* same usage as above, but also set `short_open_tags=1` if disabled
* The outer loop got an unreasonable start value in the golfing, replace `$n+1` with `ceil(strlen($n)/5)+1` or at least with `strlen($n)` for testing or it may loop like forever.
[Answer]
# Haskell, 80 (63?)
It would be 63 if there were no import statement.
```
import Data.List
f x=or$tail[isInfixOf(concat$replicate 5 b)x|b<-subsequences x]
```
### Usage
```
f "11111211"
f "11111"
f "12345" 
f "1112111"
f "4242424242"
f "-11111"
f "3452514263534543543543543543876514264527473275"
```
By the way, *consecutive* makes more sense to me than *continuously.*
(Sorry, I can't comment yet.)
[Answer]
# [CJam](https://sourceforge.net/p/cjam), 22 bytes
```
q:T,{)Tew{5*T\#)}/}%:+
```
[Try it online!](https://tio.run/##S85KzP3/v9AqRKdaMyS1vNpUKyRGWbNWv1bVSvv/f2MTUyNTQxMjM2NTINPEGBlZmJuBpYBKzE3MjY3MTQE "CJam – Try It Online")
Takes sum of 1-indexed positions of all possible repeated substrings in the input. Returns 0 if interesting, anything non-zero if boring.
[Answer]
# [Japt](https://github.com/ETHproductions/japt), 7 [bytes](https://en.wikipedia.org/wiki/ISO/IEC_8859-1)
```
øUã mp5
```
[Try it](https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&code=%2bFXjIG1wNQ&input=WwoiMTExMTEiIC8vdHJ1ZQoiMTIzNDUiIC8vZmFsc2UKIjExMTIxMTEiIC8vZmFsc2UKIjQyNDI0MjQyNDIiIC8vdHJ1ZQoiLTExMTExIiAvL3RydWUKIjM0NTI1MTQyNjM1MzQ1NDM1NDM1NDM1NDM1NDM4NzY1MTQyNjQ1Mjc0NzMyNzUiIC8vdHJ1ZQpdLW1S) (includes all test cases)
```
øUã mp5     :Implicit input of string U
ø           :Does U contain any element of
 Uã         :  Substrings of U
    m       :  Map
     p5     :    Repeat 5 times
```
[Answer]
# [Vyxal](https://github.com/Vyxal/Vyxal) `Ṡs`, 34 [bitsv2](https://github.com/Vyxal/Vyncode/blob/main/README.md), 4.25 bytes
```
K5*vc
```
[Try it Online!](https://vyxal.pythonanywhere.com/?v=2#WyIg4bmgcz0iLCIiLCJLNSp2YyIsIiIsIjExMTExMTIyMjIyMiJd)
The 05ab1e answer but in less bytes :)
[Answer]
# [JavaScript (Node.js)](https://nodejs.org), 77 bytes
```
s=>s.some((_,i)=>s.some(c=>--i<0&&([,s]+1).split([t+=[,c]]+t+t+t+t)[1],t=''))
```
[Try it online!](https://tio.run/##hcpBCsIwEEDRvQdpZkgyWOnS6bKXCEFKDBKJTXGC10@hokvlrz68@/yaJTzTWu1SrrFN3IRHISmPCHAxCb8XeLQ2nY9dB86I1z2SrDlVcFWzM8F7Xd@h672prBRiC2WRkiPlcoMJHBGp4fRJecTDD/EXDDtoGw "JavaScript (Node.js) – Try It Online")
[Answer]
# TSQL, 151 bytes
Golfed:
```
DECLARE @t varchar(99)='11111'
,@z bit=0,@a INT=1,@ INT=1WHILE @a<LEN(@t)SELECT @z=IIF(@t LIKE'%'+replicate(SUBSTRING(@t,@a,@),5)+'%',1,@z),@=IIF(@=20,1,@+1),@a+=IIF(@=1,1,0)PRINT @z
```
Ungolfed:
```
DECLARE @t varchar(99)='11111'
,@z bit=0,
@a INT=1,
@ INT=1
WHILE @a<LEN(@t)
  SELECT
    @z=IIF(@t LIKE'%'+replicate(SUBSTRING(@t,@a,@),5)+'%',1,@z),
    @=IIF(@=20,1,@+1),
    @a+=IIF(@=1,1,0)
PRINT @z
```
**[Fiddle](https://data.stackexchange.com/stackoverflow/query/509048/golf-to-find-boring-numbers)**
[Answer]
# PowerShell, 26 bytes
```
$args[0]-match"(.+)\1{4}"
```
I'm by no means a regex master, so credit to the other answers for that.
[Answer]
# Clojure, 24 bytes
```
#(re-find #"(.+)\1{4}"%)
```
Uses clojure's falsey values of `nil`/`false` and truthy values for everything else. Specifically, `nil` when no match is found for false, and an array `[]` for true when a match is found like for 11111 then `["11111" "1"]` is true.
[Answer]
# JS without regexes, 166
```
b=s=>{for(let i=0;i<s.length-4;i++){for(let n=1;n<=Math.floor((s.length-i)/5);n++){if([1,2,3,4].every(k=>s.slice(i,i+n)==s.slice(i+n*k,i+n*(k+1))))return 1}}return 0}
```
non minified:
```
// test any start pos, and length
var b = s => {
    for (let i = 0; i <= s.length - 5; i++) {
        for (let n = 1; n <= Math.floor((s.length - i) / 5); n++) {
            // test if s is boring at position i, with length n
            if ([1, 2, 3, 4].every(k => s.slice(i, i + n) === s.slice(i + n * k, i + n * (k + 1)))) {
                return 1;
            }
        }
    }
    return 0;
};
console.log(b('11111'));
console.log(b('12345'));
console.log(b('1112111'));
console.log(b('-11111'));
console.log(b('3452514263534543543543543543876514264527473275'));
```
[Answer]
# [Scala 3](https://www.scala-lang.org/), 27 bytes
```
_.matches(".*(.+)\\1{4}.*")
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m72sODkxJ9F4wU3L_KSs1OQSBd_EzDyFai4FhZLKglQFPwVbheCSosy8dAVbOwWn_Pyc1MQ8LqBsWWKOQp4VWH5paUmarsXueL3cxJLkjNRiDSU9LQ09bc2YGMNqk1o9LSVNiIqbH4H6UlLTFHKBVmgkFqUXWyk4FhUlVkZDbIjVtFIIzcssARoJsl9BoQAoWpKTp5GnoWQIAkqamhjiRsYmptjEDQ2NsOswMYJBLJK6uOwB2mJkamhiZGZsCmSaGCMjC3MzsBRQibmJubGROdRBtVy1EI8vWAChAQ)
]