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\$