A non-empty string or list of capital letters k with length between 3 to 5000.
A value indicating whether k can be expressed as a+b+b, where a and b are non-empty.
SSS SNYYY SNYY SNNYY SNYNY FALSYTESTCASES FALSYFALSYTESTCASES FALSYTESTCASESXFALSYTESTCASES FALSYTESTCASESFALSYTESTCASES SMARTIEATIE XX lowercase 123 ABC (repeated 2000 times) Takes a string and returns a Boolean value.
s=>/.(.+)\1$/.test(s) A non-regex solution.
s=>(g=i=>s[2*i]&&s.slice(-2*i)==(q=s.slice(-i))+q|g(-~i))`` 
-e, 4 bytesJtđ= Jtđ= J Split the input into a list of parts t Remove the first part đ Check that there are exactly two remaining parts = Check that the two remaining parts are equal 
cP$h_*>h_>~ʃ This uses the parser library.
h_ parses any non-empty string, so we ask if there is a h_ followed by h_ and then we feed the output of the second h_ into ʃ. Since ʃ parses any fixed string given as input, this means it parses whatever h_ gave again.
cP takes the parser we built and turns it into a function which returns true when there is at least one parse which completely consumes the string.
This is such a simple challenge it's hard for this to get any better, but I have some thoughts:
(>~ʃ) is a pretty common function. It attempts to parse the result of the last parse again. However unless I assigned it a 2 byte name it wouldn't make any savings in this particular case.(h_*>) might also be useful to have a shortcut for.
ŒHÐƤḊEƇ A monadic Link that accepts a list of characters and yields a non-empty list (truthy) if the input can be expressed as a+b+b or an empty list (falsey) otherwise.
ŒHÐƤḊEƇ - Link: list of characters, S ÐƤ - for suffixes of S: ŒH - split into half (if odd length first half is longer) Ḋ - dequeue (we don't want to test for a+a, only a+b+b) Ƈ - keep those for which: E - all equal? 
f(_:_++b++b)|b>""=1 Try it online! with truthy, or
Try it online! with falsy test case.
Thanks for a byte saved by Wheat Wizard.
b>"" instead of b/="" to save 1 byte. \$\endgroup\$ SNYYNYY produce multiple 1s. \$\endgroup\$ n;f(char*s){n=strlen(++s);return~-n&&!bcmp(s-~n/2,s+n%2,n/2)|f(s);} -1 byte from ceilingcat
-2 bytes thanks to Unrelated String
ba₁ḍ= b Remove the first character from the input a₁ Get a nonempty suffix of the remaining string ḍ Split it into two halves = Assert that both are identical The first b is necessary to prevent the prefix from being empty.
import re f=re.compile(r'.+(.+)\1$').match Python3 port of the Javascript answer.
Takes a string for input, returns a re.Match object as truthy, None as falsy.
by Jitse
f=lambda s,i=0:s>''and(s==i*s[:len(s)//2])|f(s[1:],2) lambda s:any(s.endswith(2*s[i:],1)for i in range(len(s))) Takes a string for input, returns True and False accordingly.
f=lambda s,i=0:s>''and(s==i*s[:len(s)//2])|f(s[1:],2) \$\endgroup\$ 
⊙ΦＥθ…⮌θκι⁼ιײ∕ι² Try it online! Link is to verbose version of code. Outputs a Charcoal boolean, i.e. - for a+b+b, nothing if not. Explanation:
θ Input string Ｅ Map over characters θ Input string ⮌ Reversed … Truncated to length κ Current index Φ Filtered where ι Reversed suffix (is not empty) ⊙ Any reversed suffix satisfies ι Current reversed suffix ∕ ² First half ײ Repeated twice ⁼ Equals ι Current reversed suffix Implicitly print 
Ḣᶜϩ½≈a Essentially, a case is truthy if some suffix of the input minus the first character (ensuring a is non empty) can be split into two equal halves.
Ḣᶜϩ½≈a Ḣ # Remove the first character of the string because it could be `a` ᶜϩ # Over all suffixes: ½ # Split into halves ≈ # And test whether both halves are the same a # Output whether any are true. 💎 Created with the help of Luminespire.
\(x)grep('.+(.+)\\1',x) Attempt This Online! Not a very special solution (regex taken here), but almost surely it's going to be the shortest one in R (well, until pajonk suggested to replace grepl with grep :).
grep (with 1 as truthy and integer(0) as falsy). \$\endgroup\$ Three different alternatives:
.œ3ùε¦Ë}à - Try it online or verify all test cases..s¨ε2äË}à - Try it online or verify all test cases.¦D.s2×Å¿à - Try it online or verify all test cases.Explanation:
.œ # Get all partitions of the (implicit) input-string 3ù # Only keep the partitions containing three parts ε # Map over each over each remaining partition: ¦ # Remove the first part Ë # Check if the remaining two parts are equal }à # After the map: check if any is truthy # (which is output implicitly as result) .s # Get all suffixes of the (implicit) input-string ¨ # Remove the last suffix (the input itself) ε # Map over each suffix: 2ä # Split it into two equal-sized parts (first part is larger for odd lengths) Ë # Check that both parts are equal }à # After the map: check if any is truthy # (which is output implicitly as result) ¦ # Remove the first character of the (implicit) input-string D # Duplicate it .s # Pop the copy, and push its prefixes 2× # Double each string Å¿ # Check if the input minus first character ends with a string à # Check if any is truthy # (which is output implicitly as result) Prompts for string.
×+/n=+/¨(n↑¨⊂v)=n↑¨(n←⍳⌊.5×⍴v)↓¨⊂v←⌽1↓⎕ The function takes as input a string s. It returns 0 for True cases, None for False ones.
def f(s): l=len(s) for i in range(1,l): x=(i+l)//2 if s[i:x]==s[x:]:return 0 return Explanation
The function takes as input a string s.
The i loop takes substrings of s representing b+b, starting from the second character in order to leave a non-empty substring a.
x represents the middle of the substring.
The two halves of the substring are compared: if they are equal, return 0. If no equal halves are found, return None.
SNYYNYY. \$\endgroup\$