[Question]
  [
A string of characters repeats if it contains two consecutive substrings that are equivalent.
For example, `2034384538452` repeats as it contains `3845` twice, consecutively.
Therefore, your challenge is to decide whether a string contains a repeating substring. You may take the input as a string or an array of characters.
You will never receive an empty input, and the length of the substring (if it exists) may be 1 or more.
I use `1` and `0` here as my truthy and falsy values, but you may use different values, as long as they are truthy and falsy in your language.
## Examples:
```
abcab -> 0
bdefdefg -> 1
Hello, World! -> 1
pp.pp/pp -> 1
q -> 0
21020121012021020120210121020121012021012102012021020121012021020120210121020120210201210120210121020121012021020120210121020121012021012102012021020121012021012102012101202102012021012102012021020121012021020120210121020121012021012102012021020121012021020120210121020120210201210120210121020121012021020120210121020120210201210120210201202101210201210120210121020120210201210120210121020121012021020120210121020121012021012102012021020121012021020120210121020120210201210120210121020121012021020120 -> 0
```
(The last example was generated from the amount of ones between each zero in the Thue-Morse sequence)
  
[Answer]
# [Retina](https://github.com/m-ender/retina), 6 bytes
```
(.+)\1
```
[Try it online!](https://tio.run/##K0otycxL/P9fQ09bM8bw//@klNQ0IEoHAA "Retina – Try It Online")
Positive value for truthy; zero for falsey.
## How it works
Returns the number of matches of the regex `/(.+)\1/g`.
[Answer]
# [Brachylog](https://github.com/JCumin/Brachylog), 3 bytes
```
s~j
```
[Try it online!](https://tio.run/##SypKTM6ozMlPN/r/v7gu6/9/paSU1DQgSlcCAA "Brachylog – Try It Online")
```
s~j
s    exists a sublist of input
 ~j  which is the result of a juxtaposition of something
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), ~~6~~ 5 bytes
```
Ẇµ;"f
```
This is a full program. TIO can't handle the last test case without truncating it.
[Try it online!](https://tio.run/##y0rNyan8///hrrZDW62V0v4/3L3lcPujpjWR//8nJiUnJnElpaSmAVE6lwdQZb6OQnh@UU6KIldBgV5BgX5BAVchl5GhgZGBIZA0NDKAsg3APFRxQyQ5fOoNcOgj13xDEu0jwXwA "Jelly – Try It Online") (last test case truncated to 250 digits)
### How it works
```
Ẇµ;"f  Main link. Argument: s (string)
Ẇ      Words; generate all substrings of s.
 µ     New chain. Argument: A (substring array)
  ;"   Vectorized concatenation; concatenate each substring with itself.
    f  Filter; keep "doubled" substrings that are also substrings.
       This keeps non-empty string iff the output should be truthy, producing
       non-empty output (truthy) in this case and empty output (falsy) otherwise.
```
[Answer]
# Mathematica, 32 bytes
```
StringMatchQ[___~~x__~~x__~~___]
```
[Answer]
# Java, 27 bytes
```
a->a.matches(".*(.+)\\1.*")
```
Pretty much a duplicate of the [Retina answer](https://codegolf.stackexchange.com/a/125737/20198), but there's no way Java's getting any shorter.
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 5 bytes
```
Œ2×åZ
```
[Try it online!](https://tio.run/##MzBNTDJM/f//6CSjw9MPL436/9/I0MDIwBBIGhoZQNkGYB6quCGSHD71Bjj0kWu@IYn20dv9BjT2H03cDwA "05AB1E – Try It Online")
Outputs 1 as truthy value and 0 as falsy value
### Explanation
```
Œ2×åZ
Œ     # Substrings of input
 2×   # duplicate them (vectorized)
   å  # Is the element in the input? (vectorized)
    Z # Maximum value from list of elements
```
[Answer]
# [Python](https://docs.python.org/2/), 38 bytes
```
import re
re.compile(r'(.+)\1').search
```
[Try it online!](https://tio.run/##vZK/DsIgEMZ3nuKcaGNTgdHE3TdwUAdowZLQclIWnx5L46CDJppUQo7ffcef7xLwFjs/iJRsjz5ECJqYXdB143u0TheBFvW6PHFa1qOWoelS1GMcYQdHKiWtgErVSJVBtdpM85J5r53zFRx8cO0qC9ccEGvEDWJmwZlgfIpcsAezOXvV@VPt03725tyv9/Mv3/u3f7Zwf4v4p2dCjA@QvxDYYV7HLYFpYLBDBOW9K0yR9bJMdw "Python 2 – Try It Online")
Yawn, a regex. Checks if the string contains a string of one of more characters `.+` followed by that same string that was just captured. The output search object is Truthy if there's at least one match, as can be checked by `bool`.
Using `compile` here saves over writing a lambda:
```
lambda s:re.search(r'(.+)\1',s)
```
---
# [Python](https://docs.python.org/2/), 54 bytes
```
f=lambda s:s>''and(s in(s*2)[1:-1])|f(s[1:])|f(s[:-1])
```
[Try it online!](https://tio.run/##vZKxDsIgEIb3PsU5AaYqMJLU2TdwaDqAFDXBgqWLie@O0HTQQRNNKiF3H//dwZGcvw0n1/EYTWXlRWkJQYQtQrLTOMC5w2HJSc3EijXkbnBIOMEoxaENQ4AKaiQlKgFJdZAqg9KtSfuYedda60rYu97qRRau2Xi/9n7jfWbOKKcsWcbpxHQ8versKfYpn76p@/V@9uV7/@6fzvy/WfpHTVEY10MeoTRpow@igLR8f@4GUM5ZbHDWa8FoQ0h8AA "Python 2 – Try It Online")
Searches for a substring that is composed two or more equal strings concatenated, as checked by `s in(s*2)[1:-1]` as in [this answer](https://codegolf.stackexchange.com/a/37855/20260). Substrings are generated recursively by choosing to cut either the first or last character. This is exponential, so it times out on the large test case.
Near misses:
```
f=lambda s,p='':s and(s==p)*s+f(s[1:],p+s[0])+f(s[:-1])
f=lambda s,i=1:s[i:]and(2*s[:i]in s)*s+f(s[1:])+f(s,i+1)
```
The first one doesn't use Python's `in` for checking substrings, and so could be adapted to other languages. 
[Answer]
# Pyth - ~~10~~ ~~9~~ 8 bytes
```
f}+TTQ.:
```
Returns a list of all the repeating substrings (which if there aren't any, is an empty list, which is falsy)
[Try It](https://pyth.herokuapp.com/?code=f%7D%2BTTz.%3Az&input=abcdabcd1234&test_suite=1&test_suite_input=abcab%0Abdefdefg%0AHello%2C+World%21%0App.pp%2Fpp%0Aq&debug=0)
Explanation:
```
f}+TTQ.:
      .:    # All substrings of the input (implicit):
f           # filter the list of substrings T by whether...
  +TT       # ...the concatenation of the substring with itself...
 }   Q      # ...is a substring of the input
```
[Answer]
# [Cheddar](http://cheddar.vihan.org/), 60 bytes
```
n->(|>n.len).any(i->(|>i).any(j->n.index(n.slice(j,i)*2)+1))
```
[Try it online!](https://tio.run/##TcyxDsIwDATQna8ImWJog2CnM3/AnDQuuLJcExhA4t9DBBKKdMu9k268YkohF8aHmcyxSD@49yCeUcAHeTn6Av3K3NeJJOHTib8zjejmjmBzgO0eoGgmqTfOhjiGaGH1h5hwqrm0dkLmpTPnJXNat4OqV92ptnazUD4 "Cheddar – Try It Online")
[Answer]
# [PHP](https://php.net/), 32 bytes
```
<?=preg_match('#(.+)\1#',$argn);
```
[Try it online!](https://tio.run/##K8go@G9jX5BRwJWWX5SamJyhEc2llJiUnJikpKOsoGunYMCllJSSmgZE6VARQy4lj9ScnHwdhfD8opwURYRwQYFeQYF@QQFCpBBhipGhgZGBIZA0NDKAsg3APFRxQyQ5fOoNcOgj13xDEu2jt/sNaOw/mrhfSQEa@7GJxSqJRel5mtUK9nbABGdbUJSaHp@bWAJMcOrKGnramjGGyuo6EDXW/2v/AwA "PHP – Try It Online")
# [PHP](https://php.net/), 38 bytes
```
<?=preg_match('#(.+)(?(1)\1)#',$argn);
```
[Try it online!](https://tio.run/##K8go@G9jX5BRwJWWX5SamJyhEc2llJiUnJikpKOsoGunYMCllJSSmgZE6VARQy4lj9ScnHwdhfD8opwURYRwQYFeQYF@QQFCpBBhipGhgZGBIZA0NDKAsg3APFRxQyQ5fOoNcOgj13xDEu2jt/sNaOw/mrhfSQEa@7GJxSqJRel5mtUK9nbABGdbUJSaHp@bWAJMcOrKGnramhr2GoaaMYaayuo6EJXW/2v/AwA "PHP – Try It Online")
[Answer]
# [Python 3](https://docs.python.org/3/), ~~73~~ 66 bytes
*-7 bytes thanks to @LeakyNun*
```
lambda s:any(2*s[j:i]in s for i in range(len(s))for j in range(i))
```
[Try it online!](https://tio.run/##vVLBbsIwDL33K7xTkqlA0t0qsTN/wAE4pGvKgkLqJbkgxLeXuEJiHEBiErMs6/nlJXakh4f03fuPoZuvB6f3Tash1tofePUeV7vabqyHCF0fwEKGQfut4c54HoUgdndlrRBDMjFFmMOK6eZLN6wE1rSmy7klvDDO9SUs@@DaNyJ@qCBOEWeIhCslK6lyVZW8YDl2t7z6dfZIL@/c@@v76sl5/72/fPH/XrI/2xQFeYnMQ3YaTVQXkAOD9Ymz4wkmn3A8sWnW7XXiJCkhGAy8GxuRYzgD "Python 3 – Try It Online")
[Answer]
# [Perl 6](https://perl6.org), 11 bytes
```
{?/(.+)$0/}
```
[Test it](https://tio.run/##vVHLasMwELzrK7ZgGhnLtuRDDjVpeuwHFHrJxY9NMSj2xlJKg/GX9dYfcy07hebQQgopiGVnNDO7QoStXg4Hg/C6jIqU7Y5wWzZowsqGLRJmFlYwdOuYR4HvybgfRsWDReN4XdVouP/xHhnSleULCO9h4Ue7jO5c68XQgScFrANPQc/cmKfRmjLSWQ3BlJOybdOeIkcP31Q1HayADb4RFhZLHzoGUJmwRCR9hPP1@CT3BXzJBUwM64csL7LcZUqWl7gdz4tDij2i1o2A56bV5c1MEUVEMdGM9rMrUTKRaqwqkadeTuicV9/uftPLH3x/zVcXzvvv/eWV33eV/aef/wQ "Perl 6 – Try It Online")
## Expanded:
```
{        # bare block lambda with implicit parameter ｢$_｣
  ?      # Boolify the following
         # (need something here so it runs the regex instead of returning it)
  /      # a regex that implicitly matches against ｢$_｣
    (.+) # one or more characters stored in $0
     $0  # that string of characters again
  /
}
```
[Answer]
# PHP, 32 bytes
```
<?=preg_match('#(.+)\1#',$argn);
```
Run as pipe with `-F`. Sorry Jörg, I hadn´t noticed You had [posted the same](https://codegolf.stackexchange.com/a/125741/55735).
**non-regex version, ~~84~~ 82 bytes**
```
    for($s=$argn;++$e;)for($i=0;~$s[$i];)substr($s,$i,$e)==substr($s,$e+$i++,$e)&&die
```
exits with return code `0` for a repeat, times out (and exits with error) for none. Run as pipe with `-nr`.  
assumes printable ASCII input; replace `~` with `a&` for any ASCII.
[Answer]
# JavaScript (ES6), 19 bytes
```
s=>/(.+)\1/.test(s)
```
[Answer]
# Pyth, 15 bytes
```
.E.nm.bqNYtdd./
```
[Try it!](https://pyth.herokuapp.com/?code=.E.nm.bqNYtdd.%2F&input=%22abcab%22&test_suite=1&test_suite_input=%22abcab%22%0A%22abcabc%22&debug=0)
[Answer]
# [V](https://github.com/DJMcMayhem/V), 6 bytes
```
ø¨.«©±
```
[Try it online!](https://tio.run/##K/v///COQyv0Dq0@tPLQxv//E5OSUwA "V – Try It Online")
[Test Suite!](https://tio.run/##K/v///ByPf3DOw6t0Du0@tDKQxv//09MSk5M4kpKSU0DonQuj9ScnHwdhfD8opwURa6CAr2CAv2CAq5CLiNDAyMDQyBpaGQAZRuAeajihkhy@NQb4NBHrvmGJNpHb/cb0Nh/NHE/AA "V – Try It Online")
The program outputs `0` for falsey values, and a positive integer for positive values.
(Note that there was a small bug, so I had to gain 1 byte. Now after the bugfix, I will be able to replace `.«` with `\x82`)
### Explanation
```
ø                     " This is a recent addition to V. This command takes in a regex
                      " and replaces the line with the number of matches of the regex
 ¨.«©±                " The compressed regex. This decompresses to \(.\+\)\1
```
[Answer]
# Japt, 8 ~~+ 1~~ = ~~9~~ 8 bytes
```
f"(.+)%1
```
[Try it online](http://ethproductions.github.io/japt/?v=1.4.5&code=ZiIoLispJTE=&input=ImFiYWJkYyI=). Outputs `null` for falsy, and an array containing all the repeating strings for truthy.
# Explanation
```
 f"(.+)%1
Uf"(.+)%1" # Implicit input and string termination
Uf         # Find in the input
  "(.+)%1" #   a sequence followed by itself
 f         # and return the matched substring
           # output the return value
```
[Answer]
## Cheddar, 16 bytes
```
@.test(/(.+)\1/)
```
This is a function. [Try it online!](https://vihan.org/p/tio/?l=cheddar&p=y0ktUUhTsFVw0CtJLS7R0NfQ09aMMdTX5OIqKMrMA8ppKKXnJ5aAsJImqlgSWOw/AA)
[Answer]
# [Ruby](https://www.ruby-lang.org/) `-n`, 10 bytes
Takes input on stdin. Prints the index of the first repeated substring for truthy and `nil` for falsey.
```
p~/(.+)\1/
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m72kqDSpclm0km6eUuyCpaUlaboWqwrq9DX0tDVjDPUhAlDxBbeYZBKTkhOTuJJSUtOAKJ3LIzUnJ19HITy_KCdFkaugQK-gQL-ggKuQy8jQwMjAEEgaGhlA2QZgHqq4IZIcPvXo8ujmkGo-If2E3ENr91NqP6XhQ5b7IakEAA)
]