Does it repeat?

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 1

Retina, 6 bytes

(.+)\1

Try it online!

Positive value for truthy; zero for falsey.

How it works

Returns the number of matches of the regex /(.+)\1/g.

Answer 2

Brachylog, 3 bytes

s~j

Try it online!

s~j
s    exists a sublist of input
 ~j  which is the result of a juxtaposition of something

Answer 3

Jelly, 6 5 bytes

Ẇµ;"f

This is a full program. TIO can't handle the last test case without truncating it.

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 4

Mathematica, 32 bytes

StringMatchQ[___~~x__~~x__~~___]

Answer 5

Java, 27 bytes

a->a.matches(".*(.+)\\1.*")

Pretty much a duplicate of the Retina answer, but there's no way Java's getting any shorter.

Answer 6

05AB1E, 5 bytes

Œ2×åZ

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 7

Python, 38 bytes

import re
re.compile(r'(.+)\1').search

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, 54 bytes

f=lambda s:s>''and(s in(s*2)[1:-1])|f(s[1:])|f(s[:-1])

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. 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 8

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

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 9

Cheddar, 60 bytes

n->(|>n.len).any(i->(|>i).any(j->n.index(n.slice(j,i)*2)+1))

Try it online!

Answer 10

PHP, 32 bytes

<?=preg_match('#(.+)\1#',$argn);

Try it online!

PHP, 38 bytes

<?=preg_match('#(.+)(?(1)\1)#',$argn);

Try it online!

Answer 11

Python 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!

Answer 12

Perl 6, 11 bytes

{?/(.+)$0/}

Test it

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 13

PHP, 32 bytes

<?=preg_match('#(.+)\1#',$argn);

Run as pipe with -F. Sorry Jörg, I hadn´t noticed You had posted the same.

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 14

JavaScript (ES6), 19 bytes

s=>/(.+)\1/.test(s)

Answer 15

Pyth, 15 bytes

.E.nm.bqNYtdd./

Try it!

Answer 16

V, 6 bytes

ø¨.«©±

Try it online!

Test Suite!

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 17

Japt, 8 + 1 = 9 8 bytes

f"(.+)%1

Try it online. 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 18

Cheddar, 16 bytes

@.test(/(.+)\1/)

This is a function. Try it online!

Answer 19

Ruby -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!