[Question]
  [
This is taken from [this question](https://stackoverflow.com/questions/55823298/how-do-i-check-if-a-string-is-entirely-made-of-the-same-substring) (with permission ofcourse). I'll quote:
> 
> Create a function which takes a string, and it should return true or
>  false based on whether the input consists of ***only*** a repeated character
>  sequence. The length of given string is always greater than 1 and the
>  character sequence must have at least one repetition.
> 
> 
> 
Some examples:
```
'aa' //true
'aaa' //true
'abcabcabc' //true
'aba' //false
'ababa' //false
'weqweqweqweqweqw' // false
```
Specifically, the check for a string strictly composed of repeating substrings (**Update**) can output any true or false representation, but no error output please. Strictly alphhanumeric strings. Otherwise standard code golf rules. This is Code Golf, so shortest answer in bytes for each language wins.
  
[Answer]
# JavaScript (ES6), 22 bytes
Returns a Boolean value.
```
s=>/^(.*)\1+$/.test(s)
```
[Try it online!](https://tio.run/##y0osSyxOLsosKNHNy09J/Z9m@7/Y1k4/TkNPSzPGUFtFX68ktbhEo1jzf3J@XnF@TqpeTn66RpqGemKiugIEaGoq6OuXFJWmcmEoganBrSQpGYLU8ShBMSUtMacYmxqoKoSa/wA "JavaScript (Node.js) – Try It Online")
---
# Without a regular expression, ~~33~~ 29 bytes
Returns either `null` (falsy) or an object (truthy).
```
s=>(s+s).slice(1,-1).match(s)
```
[Try it online!](https://tio.run/##y0osSyxOLsosKNHNy09J/Z9m@7/Y1k6jWLtYU684JzM5VcNQR9dQUy83sSQ5Q6NY839yfl5xfk6qXk5@ukaahnpioroCBGhqKujrlxSVpnJhKIGpwa0kKRmC1PEoQTElLTGnGJsaqCqEmv8A "JavaScript (Node.js) – Try It Online")
NB: Technically, \$s\$ is converted to a regular expression for *match()*, so the above title is a lie.
[Answer]
# [Brachylog](https://github.com/JCumin/Brachylog), ~~4~~ 3 bytes
```
ġ=Ṁ
```
[Try it online!](https://tio.run/##SypKTM6ozMlPN/pfXa6koGunoFRuX/2obcOjpuZHHcuVSopKU5VqQKy0xJziVKXah7s6HzU11D7cOuH/kYW2D3c2/P8frZSYqKQDJMBkUjIEgdkQEQhdnlqIgpRiAQ "Brachylog – Try It Online")
## Explanation
```
ġ=Ṁ    Implicit input, say "abcabc"
ġ      Split into chunks of equal lengths (except maybe the last one): ["abc","abc"]
 =     Apply the constraint that all of the chunks are equal,
  Ṁ    and that there are multiple of them.
```
The program prints `true.` if the constraints can be satisfied, and `false.` if not.
[Answer]
# grep, 19
```
grep -qxE '(.+)\1+'
```
### Test
```
while read; do 
  <<<"$REPLY" grep -qxE '(.+)\1+' && t="true" || t="false"
  echo "$REPLY: $t"
done < infile 
```
Output:
```
aa: true
aaa: true
abcabcabc: true
aba: false
ababa: false
weqweqweqweqweqw: false
```
[Answer]
# [Japt](https://github.com/ETHproductions/japt), 6 bytes
```
²é ¤øU
```
Saved one byte thanks to @Shaggy
[Try it online!](https://tio.run/##y0osKPn//9CmwysVDi05vCP0//9o9cREdR0uIAmhkpIhCMKBioEYsQq6uUEA "Japt – Try It Online")
```
        Implicit input, stored in variable 'U'
²       U+U, "abcabc" -> "abcabcabcabc"
 é      Rotate 1 char to the right "abcabcabcabc" -> "cabcabcabcab"
   ¤    Remove first two chars, "cabcabcabcab" -> "bcabcabcab"
    øU  Check if U is in the above
```
[Answer]
# Java, ~~25~~ 24 bytes
-1 byte thanks to Olivier Grégoire!  
Boring regex answer
```
s->s.matches("(.+)\\1+")
```
[Try it online!](https://tio.run/##VY09b8IwEIZ3/4oTky2Epa6JisQAWyfG0uFibHDq2KnvQoWi/HbXtF2QnvuS7tHb4w03/fmzmIBE8IY@zsJHttmhsXCYu5SCxQhOHjn7eAFS7SLGqQveADFyHbfkzzBU9f/n/QMwX0jN4gAOXgtttqQHZHO1JFdSr9Xp9LJeqdKKvubriX3Qu5zxTpo4Wxzkr1@dUbqmcUq7lPdorvJ4J7aDThM3zVizOETVimUpBbFSqzN/1O1xPfq3/XriBw)  
  
~~*It's just 1 byte longer than the python answer aaaaa*~~ I'm tied now :)
[Answer]
# Excel, 26 bytes
```
=FIND(A1,A1&A1,2)<=LEN(A1)
```
Inputs from A1, outputs to whatever cell you put this formula.
[Answer]
# [R](https://www.r-project.org/), 28 bytes
```
grepl("(.+)\\1+$",scan(,''))
```
[Try it online!](https://tio.run/##K/r/P70otSBHQ0lDT1szJsZQW0VJpzg5MU9DR11dU/O/UmISMlTiAgokgxGQWZ5aCEFIbJCKRLAyMAkCSv8B "R – Try It Online")
Simple Regex version. R is (sometimes) very similar to Python, so this is similar to TFeld's Python 2 regex answer, albeit shorter!
### Question (if anyone knows the answer)
I am still confused why this works, as the substring can be any length and will always work, and still works when I add a letter to the front of a valid string, like "cABABABABAB". If I personally read the regex, I see `(.+)`, which captures any group of any length. And then `\\1+$` which repeats the captured group any number of times until the end.
So why doesn't it capture just "AB" and find that it is repeated until the end of the string, especially since there is no restriction specified as to where the substring can start?
[Answer]
# [Retina 0.8.2](https://github.com/m-ender/retina/wiki/The-Language/a950ad7d925ec9316e3e2fb2cf5d49fd15d23e3d), 9 bytes
```
^(.+)\1+$
```
[Try it online!](https://tio.run/##K0otycxL/K@q4Z7wP05DT1szxlBb5f//xESuRBBOSoYgIAvEA0IA "Retina 0.8.2 – Try It Online") Link includes test cases.
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), ~~5~~ 4 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
I see now that the optimal way is to follow [xnor's method](https://codegolf.stackexchange.com/a/37855/53748)!
```
Ḋ;Ṗw
```
A monadic Link that accepts a list of characters and outputs an integer - the shortest possible length of a repeating slice or zero if none exists. Note that zero is falsey while non-zero numbers are truthy in Jelly.
**[Try it online!](https://tio.run/##y0rNyan8///hji7rhzunlf///z8xKRmKAA "Jelly – Try It Online")**
### How?
```
Ḋ;Ṗw - Link: list of characters, S   e.g. "abcabcabc"   or "abababa"
Ḋ    - dequeue S                           "bcabcabc"       "bababa"
  Ṗ  - pop from S                         "abcabcab"       "ababab"
 ;   - concatenate                "bcabcabcabcabcab"       "bababaababab"
   w - first index of sublist     3  ^---here!             0  (not found)
```
[Answer]
# [Perl 5](https://www.perl.org/) `-p`, 14 bytes
```
$_=/^(.*)\1+$/
```
[Try it online!](https://tio.run/##K0gtyjH9/18l3lY/TkNPSzPGUFtF////xH/5BSWZ@XnF/3V9TfUMDA3@6xYAAA "Perl 5 – Try It Online")
[Answer]
# [Pyke](https://github.com/muddyfish/PYKE), 4 bytes
```
+tO{
```
[Try it here!](https://pyke.catbus.co.uk/?code=%2BtO%7B&input=abcabc&warnings=1&hex=0)
```
+    -    input+input
 t   -   ^[1:]
  O  -  ^[:-1]
   { - input in ^
```
[Answer]
# [Python 2](https://docs.python.org/2/), 24 bytes
```
lambda s:s in(s*2)[1:-1]
```
[Try it online!](https://tio.run/##K6gsycjPM/qfZhvzPycxNyklUaHYqlghM0@jWMtIM9rQStcw9n9BUWZeiUKahnpiorqmsoK@fklRaSoXkih24aRkCMIuCdYDFE9LzClGlcAlVZ5aiIKgqhTQTYDYBxb9DwA "Python 2 – Try It Online")
Shamelessly stolen from [xnor's answer](https://codegolf.stackexchange.com/a/37855/38592) to the original question. 
---
More intuitive version:
# [Python 2](https://docs.python.org/2/), ~~59~~ ~~55~~ 53 bytes
```
lambda s:s in[len(s)/i*s[:i]for i in range(1,len(s))]
```
[Try it online!](https://tio.run/##K6gsycjPM/qfZhvzPycxNyklUaHYqlghMy86JzVPo1hTP1OrONoqMzYtv0ghEyisUJSYl56qYagDkdaM/V9QlJlXopCmoZ6YqK6prKCvX1JUmsqFJIpdOCkZgrBLgvUAxdMSc4pRJXBJlacWoiCoKgWwsv8A "Python 2 – Try It Online")
---
**Boring regex version:**
# [Python 2](https://docs.python.org/2/), 44 bytes
```
lambda s:re.match(r'(.+)\1+$',s)>0
import re
```
[Try it online!](https://tio.run/##K6gsycjPM/qfZhvzPycxNyklUaHYqihVLzexJDlDo0hdQ09bM8ZQW0Vdp1jTzoArM7cgv6hEoSj1f0FRZl6JQpqGemKiuqaygr5@SVFpKheSKHbhpGQIwi4J1gMUT0vMKUaVwCVVnlqIgqCqFMDK/gMA "Python 2 – Try It Online")
[Answer]
# [J](http://jsoftware.com/), ~~26 25 15~~ 14 bytes
Using xnor method
```
+./@E.}:@}.@,~
```
[Try it online!](https://tio.run/##y/qvpKeepmBrpaCuoKNgoGAFxLp6Cs5BPm7/tfX0HVz1aq0cavUcdOr@a3KlJmfkK6QpqCcmqisgcRLVEZykZAiCChko2EKEEzEE0IXKUwtRkPp/AA "J – Try It Online")
## original (two different approaches)
# [J](http://jsoftware.com/), 25 bytes
```
1<1#.(#%#\)=<\+/@E.&:>"{]
```
[Try it online!](https://tio.run/##y/qvpKeepmBrpaCuoKNgoGAFxLp6Cs5BPm7/DW0MlfU0lFWVYzRtbWK09R1c9dSs7JSqY/9rcqUmZ@QrpCmoJyaqKyBxEtURnKRkCIIKGSjYQoQTMQTQhcpTC1GQ@n8A "J – Try It Online")
# [J](http://jsoftware.com/), 26 bytes
```
1<1#.-@#\([:(-:##{.)<\)"{]
```
[Try it online!](https://tio.run/##y/qvpKeepmBrpaCuoKNgoGAFxLp6Cs5BPm7/DW0MlfV0HZRjNKKtNHStlJWr9TRtYjSVqmP/a3KlJmfkK6QpqCcmqisgcRLVEZykZAiCChko2EKEEzEE0IXKUwtRkPp/AA "J – Try It Online")
[Answer]
# [Wolfram Language (Mathematica)](https://www.wolfram.com/wolframscript/), ~~24~~ 23 bytes
```
StringMatchQ[x__..~~x_]
```
[Try it online!](https://tio.run/##y00syUjNTSzJTE78n2b7P7ikKDMv3TexJDkjMLoiPl5Pr66uIj72fwBQuMRBK03foZpLKTFRSQdEQqikZAiCcKBiUEZ5aiESKi8sV6r9DwA "Wolfram Language (Mathematica) – Try It Online")
```
StringMatchQ[           (*a function that checks if its input (string) matches:*)
             x__..      (*a sequence of one or more characters, repeated one or more times*)
                  ~~x_] (*and one more time*)
```
[Answer]
# GNU Bash, 28 bytes
```
[[ ${1:1}${1::-1} == *$1* ]]
```
Save the above script into a file, and run `bash file.sh "string to test"`.
Exit code 0 is truthy and non-zero is falsy. (as all Unix shells would interpret)
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 5 bytes
[xnor's method](https://codegolf.stackexchange.com/a/37855/47066) from the previous question appears to be optimal in 05AB1E as well.
```
«¦¨så
```
[Try it online!](https://tio.run/##yy9OTMpM/f//0OpDyw6tKD689P//xKRkCAIA "05AB1E – Try It Online")
or as a [Test Suite](https://tio.run/##yy9OTMpM/V9TVllZ@f/Q6kPLDq0oPrz0v45mzP/ERK5EEE5KhiAgC8QDkeWphSgIAA)
**Explanation**
```
«       # append input to input
 ¦¨     # remove the first and last character of the resulting string
   så   # check if the input is in this string
```
[Answer]
# PowerShell, ~~23~~ 24 bytes
+1 byte to fully match rules
```
"$args"-match"^(.+)\1+$"
```
[Try it online!](https://tio.run/##K8gvTy0qzkjNyfn/X0klsSi9WEk3N7EkOUMpTkNPWzPGUFtF6T9QKjEpGYiUAA "PowerShell – Try It Online")
Pretty boring. Based on the other Regex answers. Luckily PowerShell doesn't use `\` as an escape character!
[Answer]
## [C# (Visual C# Interactive Compiler)](https://www.mono-project.com/docs/about-mono/releases/5.0.0/#csc), 70 bytes
xnor's shameless adaptation (**46 bytes**)
```
s=>(s+s).Substring(1,s.Length*2-2).Contains(s)
```
My non Regex Solution:
```
s=>s.Select((x,y)=>y).Count(z=>s.Replace(s.Substring(0,z+1),"")=="")>1
```
Explanation:
Replace every possible substring that starts at index 0 with an empty string. If the result is an empty string, the string is entirely made of that substring. Since this includes evaluating the entire string with itself, the amount of expected results must be greater than 1. 
Example: **abcabc**
Possible substrings starting at index 0:
```
'a', 'ab', 'abc', 'abca', 'abcab', 'abcabc'
```
If we replace them with empty strings
```
Substring          Result
'a'         =>     'bcbc'
'ab'        =>     'cc'
'abc'       =>     ''
'abca'      =>     'bc'
'abcab'     =>     'c'
'abcabc'    =>     ''
```
Since there is a substring other than 'abcabc' that returns an empty string, the string is entirely made of another substring ('abc')
[Try it online!](https://tio.run/##bYuxCsIwFEV3v6JkesFY7KzJIjg56eCcPF4lEBJtErT9@djSSQxc7nDuuRh3GG05Z4/HmAbrH8KE4FTTN7JEqWJ7I0eYAD5i5FKNvD2F7BNMy3alp9NIMFvZrHfYi2nbccEYl3Iu1ZXD5j7YRBfrCXpgWjPO/1gNGlxTm6p@Fb/p9ZPFKF8)
[Answer]
# [Python 3](https://docs.python.org/3/), ~~62~~ ~~60~~ ~~56~~ 54 bytes
*-4 bytes thanx to [ArBo](https://codegolf.stackexchange.com/users/82577/arbo)*
```
lambda s:s in(len(s)//l*s[:l]for l in range(1,len(s)))
```
1. Iterate over all possible prefixes in the string.
2. Try to build the string out of the prefix.
3. Return whether this succeeds with any prefix at all.
[Try it online!](https://tio.run/##K6gsycjPM/6fZhvzPycxNyklUaHYqlghM08jJzVPo1hTXz9HqzjaKic2Lb9IIQcorlCUmJeeqmGoA5HX1PxfUJSZV6KRpqGUqKSpyYXgoXPR@EnJEIQmiq4KXaQ8tRAFASX/AwA "Python 3 – Try It Online")
[Answer]
# [Ruby](https://www.ruby-lang.org/) `-n`, ~~16~~ 13 bytes
-3 bytes thanks to [south](https://codegolf.stackexchange.com/users/110888/south)
For completeness, more or less the same as the other regex answers. Prints `0` for truthy, `nil` for falsey.
```
p~/^(.+)\1+$/
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m72kqDSpclm0km6eUuyCpaUlaboWawvq9OM09LQ1Ywy1VfQhYlCpBTe1ExO5EkE4KRmCgCwQD0SWpxaiIIgeAA)
[Answer]
# [Japt](https://github.com/ETHproductions/japt), 10 bytes
*Returns a positive number if truthy and 0 if falsey. If you want a bool output just add `-¡` flag*
```
å+ k@rXÃÊÉ
```
---
```
å+ k@rXÃÊÉ      Full program. Implicit input U.
                    e.g: U = "abcabcabc"
å+              Take all prefixes 
                         U = ["a","ab","abc","abca","abcab","abcabc","abcabca","abcabcab","abcabcabc"]
   k@           Filter U by:
     rXÃ        Values that return false (empty string)
                when replacing each prefix in U
                e.g: ["bcbcbc","ccc","","bcabc","cabc","abc","bc","c",""]
                                take ↑                             and ↑
                     U = ["abc","abcabcabc"]
         ÊÉ     Get U length and subtract 1. Then return the result
```
[Try it online!](https://tio.run/##y0osKPn///BSbYVsh6KIw82Huw53/v8frZ6YqK7DBSQhVFIyBEE4UDEQI1ZBNzcIAA "Japt – Try It Online")
[Answer]
# [Husk](https://github.com/barbuz/Husk), 6 bytes
```
Ṡ€ȯhtD
```
[Try it online!](https://tio.run/##yygtzv7//@HOBY@a1pxYn1Hi8v//f6XEpGQIUgIA "Husk – Try It Online")
I feel like this is one byte more than optimal, but I couldn't find an arrangement that made the explicit composition `ȯ` unnecessary.
# Explanation
```
Ṡ€      Find the argument in the result of applying the following function to the argument
  ȯhtD  Duplicate the argument, then remove the first and last elements.
```
[Answer]
# Mathematica 11.x, 74 bytes
```
{}!=StringCases[#,StartOfString~~x__/;(x!=#&&StringReplace[#,x->""]=="")]&
```
where, throughout, `#` represents the input string, and
```
StringCases[#,<pattern>]
```
finds substrings of the input string matching the pattern
```
StartOfString~~x__/;(x!=#&&StringReplace[#,x->""]=="") 
```
This pattern requires matches, `x`, must start at the start of the string and must satisfy the condition that (1) the match is not the whole input string and (2) if we replace occurrences of the match in the input string with the empty string we obtain the empty string. Finally, comparing the list of matches to the empty list,
```
{}!=
```
is `True` if the list of matches is nonempty and `False` if the list of matches is empty.
Test cases:
```
{}!=StringCases[#,StartOfString~~x__/;(x!=#&&StringReplace[#,x->""]=="")]&["aa"]
(*  True  *)
{}!=StringCases[#,StartOfString~~x__/;(x!=#&&StringReplace[#,x->""]=="")]&["aaa"]
(*  True  *)
{}!=StringCases[#,StartOfString~~x__/;(x!=#&&StringReplace[#,x->""]=="")]&["abcabc"]
(*  True  *)
```
and
```
{}!=StringCases[#,StartOfString~~x__/;(x!=#&&StringReplace[#,x->""]=="")]&["aba"]
(*  False  *)
{}!=StringCases[#,StartOfString~~x__/;(x!=#&&StringReplace[#,x->""]=="")]&["ababa"]
(*  False  *)
{}!=StringCases[#,StartOfString~~x__/;(x!=#&&StringReplace[#,x->""]=="")]&["weqweqweqweqweqw"]
(*  False  *)
```
[Answer]
# Python 3, 84 bytes
```
import textwrap
lambda s:any(len(set(textwrap.wrap(s,l)))<2 for l in range(1,len(s)))
```
Uses `textwrap.wrap` (thanks to [this answer](https://stackoverflow.com/a/48860937/4533885)) to split the string into pieces of length `n` to test each possible length of repeating substring. The split pieces are then compared to each other by adding them to a set. If all of the pieces are equal, and the set is of length 1, then the string must be a repeating string. I used `<2` instead of `==1` because it saves a byte, and the length of the input string was guaranteed to be greater than zero.
If there is no `n` for which repeating substrings of length `n` make up the entire string, then return false for the whole function.
[Answer]
# [Clean](https://github.com/Ourous/curated-clean-linux), 73 bytes
*Doesn't use regex.*
```
import StdEnv,Data.List
$s=or[isPrefixOf s(cycle t)\\t<-tl(tails s)|t>[]]
```
[Try it online!](https://tio.run/##VYy7CsIwFEB3vyJDoS1Yv8A61UEoWOiYZrikiVzIQ3Ovj4Lfbiw4CWc5wznaGQjZx/nujPCAIaO/xsRi5PkYHtsOGHY9Em8KamOSSEMyFl9nK6jSi14rrqeJ9w27igEdCarffJBK5ZFhHbWiELJ8mtsfpcofbR1cKDenPndLAI/6J4MDtjH5Lw "Clean – Try It Online")
Defines `$ :: [Char] -> Bool`.  
Checks if the given string is a prefix of the repetition of any sub-string taken from the end.
[Answer]
# [Zsh](https://www.zsh.org/), 19 bytes
Outputs via error code:
```
[[ $1$1 = ?*$1*? ]]
```
[Try it online!](https://tio.run/##qyrO@F@ekZmTqlCUmpiikJOZl2qtkJLPVZxaoqCrq6ACEvgfHa2gYqhiqGCrYK@lYqhlrxAb@z81OSNfQcWeKyUfqCCRKxGEgDgpMQlMgCggCaO4AA "Zsh – Try It Online")
However, the challenge did specify "output on stdout":
### [Zsh](https://www.zsh.org/), 22 bytes
Outputs an empty string if true, and a non-empty string for false:
```
<<<${${:-$1$1}/?*$1*?}
```
If the output must be fixed:
### [Zsh](https://www.zsh.org/), 25 bytes
Outputs `0` for true, `1` for false
```
[[ $1$1 = ?*$1*? ]]
<<<$?
```
[Try it online!](https://tio.run/##qyrO@F@ekZmTqlCUmpiikJOZl2qtkJLPVZxaoqCrq6ACEvgfHa2gYqhiqGCrYK@lYqhlrxAby2VjY6Ni/z8lHyidyJUIQkCclJgEJkAUkIRRXAA "Zsh – Try It Online")
---
The heart of these solutions is `?*$1*?`, which is a glob which matches the string in question surrounded by at least one character on each side: `*` is a string of any length, and `?` is a single character. This is an alternate version of xnor's solution, but using globs to match extra characters rather than removing leading and trailing characters.
[Answer]
# [C++ (gcc)](https://gcc.gnu.org/), 36 bytes
```
#define f(x)(x+x).find(x,1)<x.size()
```
[Try it online!](https://tio.run/##bZBNDsIgEIX3nGJCF0KsGrcV60XcIKUNiUItVInGs1faGu2PL5MALx9vYERZrgohmkhpca4zCUwZ6yrJLyn6ecFRuhg6NymcqdImymSutISceEr80tN1OGbEx1vK/NqqhyS0UdrBhSsNhMITQZAw2jqwLkuSPol1@08fULqsHew/cCvMOY5hrM3GVbUcIjNmhpxEXz9wjvxJyfnZjpkpNWPu8jqqgA@Z1w51a24qILx2Bjwk/cfpN6QbijBhFmjYizEg7cDhALh9PA43cReN6RRcHPVih17NGw "C++ (gcc) – Try It Online")
Another port of xnor's solution. Uses a macro to expand the argument into the expression. The argument is assumed to be of type `std::string`.
[Answer]
# [K (ngn/k)](https://codeberg.org/ngn/k), 11 bytes
```
&/1_=':#'=:
```
[Try it online!](https://ngn.codeberg.page/k#eJxLs1LTN4y3VbdSVre14uJKi1ZKTEqGIKVYCDcRzkhCsICyANfzEKQ=)
*Thanks to PyGamer0 for the "check if all the values of a list are equal" code snippet!*
Return `1` for true and `0` for false
Explanations:
```
&/1_=':#'=:  Main function. Takes implicit input with : on the right-most
         =   Group the characters into a dictionary
       #'    Get the length in the values of each of the keys
             (The values are the occurence positions of the characters in the string)
      :      Apply everything on the left to the right
    ='       Check if the values of the values in the dictionary are equal
  1_         Weed out the first one (as we know it will always be false)
&/           Get the minimum value
```
[Answer]
# [Vyxal](https://github.com/Vyxal/Vyxal) `r`, ~~5~~ 4 bytes
```
dḢṪc
```
*-1 byte by porting [xnor's answer](https://codegolf.stackexchange.com/questions/37851/string-prototype-isrepeated/37855#37855) from the other question*
[Try it online!](https://vyxal.pythonanywhere.com/#WyJyQSIsIiIsImThuKLhuapjIiwiIiwiJ2FhJ1xuJ2FhYSdcbidhYmNhYmNhYmMnXG4nYWJhJ1xuJ2FiYWJhJ1xuJ3dlcXdlcXdlcXdlcXdlcXcnIl0=)
Concatenates the string to itself, removes the first and last characters, then checks if the input string is in that.
[Answer]
# QlikView Variable, 27 bytes
This should be defined as a variable, which then allows you to pass parameters, e.g. `$1` as your input value.
It returns `0` or `-1` (equivalent to QlikView's `TRUE()` function).
```
=substringcount($1&$1,$1)>2
```
]