[Question]
  [
## Challenge
Given an input string `X`, determine if `X` can be obtained from reshaping a *strict prefix* of itself (a prefix that is not `X` itself).
Reshaping a string to a length `N` means repeating the string as many times as needed and then taking the first `N` characters of it.
## Examples:
The string `"abba"` returns Truthy becacause `"abb"` can be reshaped to length 4 to obtain `"abba"`.
The string "acc" returns Falsy becacause none of its strict prefixes (`"a"`, `"ac"`) can be reshaped to obtain `"acc"`.
(Outputs must be consistent)
## Test cases:
```
AA => 1
ABAba => 0
!@#$%&()_+! => 1
AAc => 0
ababababba => 1
abcdeabc => 1
abacabec => 0
@|#|#|@#|@||@#@||@|#| => 1
10101101101010110101011101111011110110110101101101010110010101101101010110 => 1
17436912791279205786716328174301174187417348216070707180471896347218574617954278517034215720138543912791279205786716328174301174187417348216070707180471896347218574617954278517034215720286716328174301174187417348216070707180471896347218574617954278517034219127912792057867163281743011741874173482160707071804718963472185746179542785170342157205720475941259275912791279205786716328174301174187417348216070707180471896347218574617954278517034215720475941252867163281743011741874173482160707071804718963472185746179542785170342157204759412517436912791279205786716328174301174187417348216070707180471896347218574617954278517034215720138543912791279205786716328174301174187417348216070707180471896347218574617954278517034215720286716328174301174187417348216070707180471896347218574617954278517034219127912792057867163281743011741874173482160707071804718963472185746179542785170342157205720475941259275912791279205786716328174301174187417348216070707180471896347218574617954278517034215720475941252867163 => 1
```
  
[Answer]
# [Retina](https://github.com/m-ender/retina/wiki/The-Language), 10 bytes
```
^(.+).*\1$
```
[Try it online!](https://tio.run/##K0otycxLNPyvquGe8D9OQ09bU08rxlDl/39HJ8ekRC5FB2UVVTUNzXhtRS5Hx2SuxCQIBEolJiWnpAIJkFhyYlJqMpdDjTIQOgBRDZAEEUAul6EBEEKQARIFxnACKo6szABDBAA "Retina ‚Äì Try It Online")
Works in any flavor of regex that supports backreferences.
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 10 bytes
```
‚äôŒ∏‚Åº‚Ä¶Œ∏Œ∫‚úÇŒ∏¬±Œ∫
```
[Try it online!](https://tio.run/##S85ILErOT8z5/z@gKDOvRMMxr1KjUEfBtbA0MadYw7kyOSfVOSO/ACSWramjEJyTmZwK4vilpieWpGpka4KA9f//hgZACEEGSBQYwwmoOLIyAwyR/7plOQA "Charcoal ‚Äì Try It Online") Link is to verbose version of code. Explanation: Simply checks whether any prefix of the input is also a suffix. The edge case of the empty prefix is ignored because you can't slice an empty suffix using a negative slice offset.
```
 Œ∏          Input string
‚äô           All indices satisfy
    Œ∏       Input string
   ‚Ä¶        Truncated to length
     Œ∫      Current index
  ‚Åº          Equals
       Œ∏    Input string
      ‚úÇ     Sliced from
         Œ∫  Current index
        ¬±   Negated
```
[Answer]
# [Ruby](https://www.ruby-lang.org/) -n, 15+1 bytes
```
p ~/^(.+).*\1$/
```
[Try it online!](https://tio.run/##KypNqvz/v0ChTj9OQ09bU08rxlBF////xKSkRK7E5OR/@QUlmfl5xf918wA "Ruby ‚Äì Try It Online")
[Answer]
# [Haskell](https://www.haskell.org/), 56 bytes
```
f s=any(and.zipWith(==)s.cycle.(`take`s))[1..length s-1]
```
[Try it online!](https://tio.run/##ZU/LCoMwELz3K2JsS0LboB8gmN577kFE1xirGIM0uVj8dxsfFKHM7My@Drs1mFYqNU0VMhHogYAu2afpn42tSRRRw8QglGQkt9DK3FCahIwpqV@2RuYWppOVxhoUoQTzOy8AXxH2Yv94OhOaXby55FzMBsWKdQcKUUon20RAIZc8Hn2H2HF0Oosr50EYOKwMdrbET7b@fi346@D0cOig0e7oDvpHhkj/brRlFUXLM9MX "Haskell ‚Äì Try It Online")
---
# [Haskell](https://www.haskell.org/), ~~54~~ 53 bytes
Based on [Neil's answer](https://codegolf.stackexchange.com/a/239797/64121): Checks if any proper prefix is a suffix.
```
import Data.List
f s=init(1<$s)>(1<$inits s\\tails s)
```
[Try it online!](https://tio.run/##ZU9BDoIwELzzilLQ0GgI3MVQ41FfIIZsocRGQEJ75O91C8SQmNnO7MzuYfsC/ZZta63qhs9oyBUMxDeljdcQnalemSg9hZqdnTiriS4KA6rFhlkjNSYZeVB@4QLokVA/D8LdPmLlwXeW88oJiAXLDoiqlkjrpAIh5z6fAkSONSE7QusGaYJYKtnI/H605tu15C@hT8/rQPV4dAfDvSTRMKrexA0j82fsFw "Haskell ‚Äì Try It Online")
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 5 bytes
```
·πÅ∆§inL
```
[Try it online!](https://tio.run/##y0rNyan8///hzsZjSzLzfP4/3L3l0NbD7UcnPdw5QzPy///EpOSUVCDBlZiUmJyYlJoMAA "Jelly ‚Äì Try It Online")
## How it works
```
·πÅ∆§inL - Main link. Takes a string S on the left
 ∆§    - Over each prefix P of S:
·πÅ     -   Mold to length S
  i   - First index of S
    L - Length of S
   n  - Are these two unequal?
```
Essentially, the index and length will only be equal if the only reshaped prefix equal to S is the full prefix i.e. a non-proper prefix
[Answer]
# Haskell, 57 bytes
```
f x|l<-length x=or[x==take l(cycle$take n x)|n<-[1..l-1]]
```
[Try it Online!](https://tio.run/##ZUpbCoMwELzK@miJtIp@twHTa4iUJI1VjKlYPyx493SjUoQys7M7O1Pzd6u0traCib6GYqJ05K0iGqaIyI/UKnQeDPrZXOMiSxLM4qwsL5pqZZ5jbTveGKDQD40ZgXS8hwoKn92Y4P4ZfC8PwsORRPeT5yxj0i0uVqwdLuRDoWyJ5EItdz4HiBw5ozpB64IsRaxMd2uZn2z/fS39@/hlZL8)
-2 bytes thanks to ovs
[Answer]
# [Vyxal](https://github.com/Vyxal/Vyxal) `r`, 7 bytes
```
L?¬¶·π™v·∫éc
```
[Try it Online!](https://vyxal.pythonanywhere.com/#WyJyIiwiIiwiTD/CpuG5qnbhuo5jIiwiIiwiJ2FiY2EnIl0=)
```
   ·π™    # All but last 
  ¬¶     # Of prefixes
 ?      # Of the input
    v   # Each
     ·∫é  # Extended to...
L       # Input length
      c # Includes input
```
[Answer]
# [BQN](https://mlochbaum.github.io/BQN/), 11 bytes[SBCS](https://github.com/mlochbaum/BQN/blob/master/commentary/sbcs.bqn)
```
‚äë‚ãà‚àä‚â†‚•ä¬®2‚Üì¬ª‚àò‚Üë
```
[Run online!](https://mlochbaum.github.io/BQN/try.html#code=RiDihpAg4oqR4ouI4oiK4omg4qWKwqgy4oaTwrviiJjihpEKCj4o4ouI4p+cRinCqOKfqCJBQkFiYSIKIiFAIyQlJigpXyshIgoiQUFjIgoiYWJhYmFiYWJiYSIKImFiY2RlYWJjIgoiYWJhY2FiZWMiCiJAfCN8I3xAI3xAfHxAI0B8fEB8I3wiCiIxMDEwMTEwMTEwMTAxMDExMDEwMTAxMTEwMTExMTAxMTExMDExMDExMDEwMTEwMTEwMTAxMDExMDAxMDEwMTEwMTEwMTAxMDExMCIK4p+p)
Notes:
A train which roughly translates to `{‚äë(‚ãàùï©)‚àä(‚â†ùï©)‚•ä¬®2‚Üì¬ª‚àò‚Üëùï©}` akin to APL, except we have a single byte prefixes builtin.
-1 from ovs.
[Answer]
# [Brachylog](https://github.com/JCumin/Brachylog), 5 bytes
```
~ca‚ÇÄ·µà
```
[Try it online!](https://tio.run/##SypKTM6ozMlPN/pfXa6koGunoFRuX/2obcOjpuZHHcuVSopKU/WUakDMtMScYiC79uGuztqHWyf8r0tOfNTU8HBrx///0UqOjko6CkqOTo5JiSCGooOyiqqahma8tiJY3DEZRCUmQSBETWJSckoqkIDKJCcmpYLZDjXKQOgARDVAEkQAuSAJQwMghCADJAqM4QRUHFmZAYaIko6SoVIsAA "Brachylog ‚Äì Try It Online")
Ungodly slow on even mid-sized failing inputs; the essentially equivalent `~c‚ÇÇa‚ÇÄ·µà` is much more performant: [Try it online!](https://tio.run/##SypKTM6ozMlPN/pfXa6koGunoFRuX/2obcOjpuZHHcuVSopKU/WUakDMtMScYiC79uGuztqHWyf8r0t@1NSU@Kip4eHWjv//o5UcHZV0FJQcnRyTEkEMRQdlFVU1Dc14bUWwuGMyiEpMgkCImsSk5JRUIAGVSU5MSgWzHWqUgdABiGqAJIgAckEShgZACEEGSBQYwwmoOLIyAwwRJR0lQ6VYAA "Brachylog ‚Äì Try It Online")
```
~c       Some partition of the input
    ·µà    is a list of two elements such that the first has the second as
  a‚ÇÄ     a nonempty prefix.
```
[Answer]
# [Husk](https://github.com/barbuz/Husk), 7 bytes
```
·πÅ»Ø‚Ç¨t·π´¬π·∏£
```
[Try it online!](https://tio.run/##yygtzv6f@6ip8f/DnY0n1j9qWlPycOfqQzsf7lj8////aCVHJ8ekRCUdJUUHZRVVNQ3NeG1FIM/RMRlIJiZBIFhBYlJySiqQgIgnJyalgpgONcpA6ABENUASRAC5QHFDAyCEIAMkCozhBFQcWZkBhohSLAA "Husk ‚Äì Try It Online")
Same approach as [Neil's answer](https://codegolf.stackexchange.com/a/239797/95126) and [tsh](https://codegolf.stackexchange.com/users/44718/tsh)'s comment: 'is any prefix of input string also one of its suffixes?'
```
·πÅ»Ø    ·∏£  # map over each of the prefixes of the input:
  ‚Ç¨      #  is it present within...
   t     #  the tail of (=drop the first element of)...
    ·π´¬π   #  the suffixes of the input?
·πÅ        # sum the answers
         # (so output is non-zero (truthy) for re-shapable strings)
```
[Answer]
# [Haskell](https://www.haskell.org/) + [hgl](https://gitlab.com/WheatWizard/haskell-golfing-library), 13 bytes
```
cP$h_<*h'>~ É
```
If you can simply submit a parser object, then that can be 10 bytes:
```
h_<*h'>~ É
```
## Explanation
* `h_` parses at least one thing off the front of a list (think `.+` in regex).
* `h'` parses any amount off the front of a list (think `.*` in regex).
* `É` is a function which takes an string and produces a parser which matches exactly that string.
We combine the two with `<*` which runs both sequentially giving the result of the first. Then we bind this to `É`, so that the result of `h_` is passed as the input to `É`.
In do notation this would be
```
do x<-h_;h'; É x
```
Described in plain English this matches any string that contains the same non-empty section at both the start and end.
# Non-parser, ~~17~~ 15 bytes
The parsers are obviously the way to go for this challenge, but I thought I'd give it a go without them to see how good hgl does.
```
lt 2<(cn**sw)sx
```
## Explanation
* `sx` gets all prefixes of a list
* `sw` checks if a particular list starts with another.
* `cn` counts the number of elements that satisfy a predicate.
* `(**)` is an infix for `liftA2`.
So altogether `(cn**sw)sx` counts the number of suffixes of the list are also prefixes.
Now, the empty string and the input string should always pass this test. So we want to test if there is *another* string which also is both a prefix and a suffix. So we use `lt 2` to check that's greater than `2`.
## Notes
Some things that could have been better for hgl in this challenge.
* There should be a function `lt2=lt 2` (and `gt1`, `lt3` etc.). That would have saved a byte here.
* `(**)` has the default precedence which although not causing any issues here, could probably be improved.
* Variants of `px` and `sx` that give for example non-empty or strict prefixes / suffixes would probably be useful. If I had a function that specifically gave non-empty and strict suffixes then I could just do `ay**sw$sxS` (where `sxS` is the imagined function) for 10 bytes.
[Answer]
# [JavaScript (Node.js)](https://nodejs.org), 52 bytes
```
s=>s.replace(/./g,c=>((p+=c)+p).indexOf(s)+1,p='')>1
```
[Try it online!](https://tio.run/##ZYxRS8MwFIXf8ysypiaX1qx5LintwGd/gIpL03RGuiY0RQrO315T08lgnJsTzrkf91N@Sa8G48bH3jZ6bsXsReHZoF0nlaY7tjumShSUukQoSBww0zd6em6ph4SnThACBZ9zfEDVvqolFgXO0Kbc3t0/UHhPNkvBUVWpuJF1VCR5yKrRwS5JKlnrlS3P26AyzDn4YiFGkGdBcbKr7@/929pfY9lNE@8d2DiYEwXmXWdGSl57Aqy1w5NUH3RamG@EsbK9H/GLSbF@wwJPF3rZE8hXwnaadfZIW2oA0A/k8y8 "JavaScript (Node.js) ‚Äì Try It Online")
Partial based on Redwolf Programs's answer.
---
# [JavaScript (Node.js)](https://nodejs.org), 56 bytes
```
s=>(g=p=>s[0]&&(p+=s.shift())==(q=s.pop()+q)|g(p))(q='')
```
[Try it online!](https://tio.run/##ZYzhaoMwFIX/@xS3dKu52AX9LREd7CmcrDGNNsWZ1MgozD27i4sthXFuTjjnftwz/@JWDMqML70@yrlhs2UZaZlhmS3jarcjJmKW2pNqRoLIGLm4aLQhGF1waolBdFUY4pzCIShei5oDyyAONvn26XlH8CPaLEUSFIXwG157eTJxWRyls1vigtdyZfNp65S7mZwv5qIHk9jJT/zw/b27rf0jFv9r/L0DHQf1SZBa06mRhO99iLTRwxsXJ3JdmO8AQOjejlCqPcgKGFxv9LIPMV0J3Una6ZZEDSkppapCYAwiuYd7gcEPpvMv "JavaScript (Node.js) ‚Äì Try It Online")
[Answer]
# [J](http://jsoftware.com/), 11 bytes
```
e.#$&><\@}:
```
[Try it online!](https://tio.run/##y/qvpKeepmBrpaCuoKNgoGAFxLp6Cs5BPm7/U/WUVdTsbGIcaq3@a3JxpSZn5ANlbRXSFNQdnRyTEtUhQoYQIUUHZRVVNQ3NeG1FdVS1jsmoKhOTIBDdhMSk5JRUIIGqHagyOTEpFc0MhxplIHQAohogCSKAXFQlhgZACEEGSBQYwwmoOLIyAwwRda7/AA "J ‚Äì Try It Online")
This one is kind of tailor made for J.
* `e.` Is the input an element of...
* `<\@}:` Each prefix except the last...
* `#$&>` Shaped to the original input's length.
[Answer]
# [Python 3](https://docs.python.org/3/), 55 bytes
```
lambda s:any(s in s[:x]*len(s)for x in range(1,len(s)))
```
[Try it online!](https://tio.run/##K6gsycjPM/6fZhvzPycxNyklUaHYKjGvUqNYITNPoTjaqiJWKyc1T6NYMy2/SKECJFiUmJeeqmGoAxHW1PxfUJSZV6KRpqGemJysrqnJheAnJSUCBf4DAA "Python 3 ‚Äì Try It Online")
Porting regexes are boring, so non regex one
[Answer]
# [Python 3](https://docs.python.org/3/), 49 bytes
```
f=lambda s,i=1:s>s[:i]and(s[i:]==s[:-i])|f(s,i+1)
```
[Try it online!](https://tio.run/##bUxdS8NAEHzPr9imKnc0Sg7fAldyKULFYl8KFmKQyxddiDF4ESumvz3ueVUKyuzOMrOz2330u5f2ehxr2ejnvNRgApQiMnOTRpjptmQmxSiTkvQlZnyoGSVmgo/vO2wqEJEHABjsJbbdW8/4leka7JkPcg4@t8vuFdueYeA/3n8marVabyBZb@HhdrOE7eEfc7G8Wdwd/LRmyKW0x3ue8VElKtf2behN4unZ@QXjT7OJNYSnVOE2OndwSUG6KCuiH6ULnVfHbDxMCTHVQGyJpAuKkOAqPBnf/UtH/zQW/nHcvy8 "Python 3 ‚Äì Try It Online")
[Answer]
# JavaScript (ES6), 23 bytes
```
x=>/^(.+).*\1$/.test(x)
```
[Try it online!](https://tio.run/##y0osSyxOLsosKNHNy09J/Z9o@7/C1k4/TkNPW1NPK8ZQRV@vJLW4RKNC839yfl5xfk6qXk5@ukaihlJiUnKikqbmfwA "JavaScript (Node.js) ‚Äì Try It Online")
Or if a function that can't be bound to a variable is allowed, 17 bytes:
```
/^(.+).*\1$/.test
```
[Try it online!](https://tio.run/##y0osSyxOLsosKNHNy09J/Z9o@18/TkNPW1NPK8ZQRV@vJLW45L@GUmJScqKSprVCcn5ecX5Oql5OfrpGouZ/AA "JavaScript (Node.js) ‚Äì Try It Online")
Regex completely stolen from [G B's answer](https://codegolf.stackexchange.com/a/239806/100664), go upvote that!
[Answer]
# [R](https://www.r-project.org/), ~~74~~ ~~72~~ 70 bytes
Or **[R](https://www.r-project.org/)>=4.1, 63 bytes** by replacing the word `function` with a `\`.
*Edit: -2 bytes thanks to [@Dominic van Essen](https://codegolf.stackexchange.com/users/95126/dominic-van-essen).*
```
function(s,n=sum(s|1)){for(i in 2:n)T=T&any(s[1:i-1]-s[n+2-i:1]);!T+1}
```
[Try it online!](https://tio.run/##dU7BDoIwDL37FQOUbEGSjZPBYJg377sRYgayZAdHwuBgxG/HKYqoWV77mravL20GkQyiU2UrawX1WiW6O0PdE4Suom6gBFKBKFaIJczn6gJ1RmIZkjzUmQqiUMYkR1uHBeQ2CNi1YsPqg2qhS/e04C5CHkh2AC@@dk7qLVc@RMfAeSvIt4LS0nLLixEfc/IrKE@VIeual7yobPZp7xmkJnrDDzKtxYpggzHwrDxzotd8LsN/E9uv05PDHQ "R ‚Äì Try It Online")
Non-regex approach (that would be simple port of other answers: `function(s)grepl("^(.+).*\\1$",s)`).
Takes input as a vector of char codes.
Outputs `NA` as truthy and `FALSE` as falsy.
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), ~~8~~ 7 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
```
.sI¬®Œ∑√•√†
```
-1 byte by porting [*@Neil*'s Charcoal answer](https://codegolf.stackexchange.com/a/239797/52210).
[Try it online](https://tio.run/##yy9OTMpM/f9fr9jz0Ipz2w8vPbzg///EpKREAA) or [verify all test cases](https://tio.run/##yy9OTMpM/V9TVmmvpPCobZKCkn3lf73iykMrzm0/vPTwgv86/xOTkhK5EpOTuRydHIEsRQdlFVU1Dc14bUUuR8dkrsQkCAQpSkpOSQUSILHkxKTUZC6HGmUgdACiGiAJIoBcLkMDIIQgAyQKjOEEVBxZmQGGCBdIkAvEBwA).
**Original 8 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage) answer:**
```
¬®Œ∑IgŒ¥‚àçI√•
```
[Try it online](https://tio.run/##yy9OTMpM/f//0Ipz2z3Tz2151NHreXjp//@JSUmJAA) or [verify all test cases](https://tio.run/##yy9OTMpM/V9TVmmvpPCobZKCkn3l/0Mrzm2vTD@35VFHb@Xhpf91/icmJSVyJSYnczk6OQJZig7KKqpqGprx2opcjo7JXIlJEAhSlJSckgokQGLJiUmpyVwONcpA6ABENUASRAC5XIYGQAhBBkgUGMMJqDiyMgMMES6QIBeIDwA).
**Explanation:**
```
.s        # Get the suffixes of the (implicit) input
  I¬®      # Push the input-string, and remove its last character
    Œ∑     # Get the prefixes of this string
     √•√†   # And check if any is in the suffixes-list
          # (after which the result is output implicitly)
¬®         # Remove the last character of the (implicit) input-string
 Œ∑        # Take its prefixes
    Œ¥     # Map over each prefix:
     ‚àç    #  And extend each to a length equal to
  Ig      #  the length of the input
      I√•  # Then check if the input is in this list
          # (after which the result is output implicitly)
```
The second program could have been 7 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage) if the input is never an integer by removing the `g`, because `‚àç` will extend to the length of given string and list arguments: [verify (almost) all test cases without `g`](https://tio.run/##yy9OTMpM/V9TVmmvpPCobZKCkn3l/0Mrzm2vPLflUUdv5eGl/3X@JyYlJXIlJidzOTo5AlmKDsoqqmoamvHailyOjslciUkQCFKUlJySCiRAYsmJSanJXA41ykDoAEQ1QBJEALlchgYGhlyGhgaGAA), and see how it now fails for `1001` and `1101`.
[Answer]
# Excel, 72 bytes
```
=LET(x,SEQUENCE(LEN(A1)/2),OR(SUBSTITUTE(LEFT(A1,x),RIGHT(A1,x),"")=""))
```
[Link to Spreadsheet](https://1drv.ms/x/s!AkqhtBc2XEHJnXNfaViRe8wWhqq3?e=lshBEv)
String comparisons in Excel are not case sensitive but `SUBSTITUTE` is.
[Answer]
# [APL (Dyalog Unicode)](https://www.dyalog.com/), 10 bytes
```
‚äÇ‚àä‚â¢‚ç¥¬®¬Ø1‚Üì,\
```
[Try it online!](https://razetime.github.io/APLgolf/?h=AwA&c=S3vUNuFRV9Ojjq5HnYse9W45tOLQesNHbZN1YgA&f=S1NQT09MTEyHIhBbHQA&i=AwA&r=tryapl&l=apl-dyalog&m=dfn&n=f# "Goto The APL Orchard")
From [Kamila's answer](https://stackoverflow.com/a/70396007/16457512) and upvote that!
[Answer]
# [R](https://www.r-project.org/), ~~77~~ ~~73~~ 69 bytes
```
function(s)any(grepl(s,paste0(r<-substring(s,0,nchar(s):1-1),r),f=T))
```
[Try it online!](https://tio.run/##bY7RCoIwFIbvewu1YocmzNtIcD1D93I2pwmxZNOLwHe3U0aYi//sP@zbv8NxU@tLZ/wVO1PlUz1Y3bd3yzygfbDGme7GPO/Q90Ywd0r9oHzvWtsQFdzqKzrKHrM0A@6A1/kFYDmSxfIsFcaw@YFRkWx3ewblIVo/SanXCNWscA4qXRmyPz80KhPwYkxIBdVI/jK6rkOZIM0lFu19vvbhy5gISLBWDNMT "R ‚Äì Try It Online")
Outputs `TRUE`/`FALSE`.
[Answer]
# JavaScript (ES6), 64 bytes
*-13 thanks to @pxeger*
```
s=>[...s].some((_,i)=>!s.slice(0,i).repeat(s.length).indexOf(s))
```
[Answer]
# [Vyxal](https://github.com/Vyxal/Vyxal), 9 bytes
```
K'?~‚Ä¢f‚Åº;‚ÇÉ
```
[Try it Online!](https://vyxal.pythonanywhere.com/#WyIiLCIiLCJLJz9+4oCiZuKBvDvigoMiLCIiLCJbXCJhXCIsIFwiYlwiLCBcImJcIiwgXCJhXCJdIl0=)
Ah yes, the limitations of type overloading. Returns `0` for Truthy inputs and `1` for Falsey inputs.
## Explained
```
K'?~‚Ä¢f‚Åº;‚ÇÉ  # Takes input as a list of characters
K          # Prefixes of the input
 '         # Keep items where:
  ?~‚Ä¢      #   The item molded to the shape of the input
     f‚Åº    #   is the same as the input (i.e. non-vectorised equality)
       ;   # Close filter.
        ‚ÇÉ  # Is the length of the list 1? For falsey inputs, the resulting list will just contain the input meaning it doesn't have any truthy prefixes.
```
[Answer]
# Wolfram Language (Mathematica), 82 Characters
[Try Online](https://tio.run/##XYsxCsJAEEV7T/FJwGotPEBgW0FQNN04xbiMyaBZJEwj4tnXFbGxfO@/P4mPOolbklL2s2Wn3YwY0cv5prQAcPSqh4PeVZy@0MtVqQ0wDjjRJl8smz8qfPrfY6t58DG2jK5DjZ8W/hassH4xltRISg1zKW8)
Practically the most basic answer I could think of. Tried some fancy things like converting into a list of characters or using some sort of trick instead of StringRepeat, but the bytes came out better this way.
```
Or@@Table[
StringRepeat[StringTake[#,i],‚àû,StringLength@#]==#,{i,StringLength@#-1}]&
```
Explanation:
Iterates i from 1 to the length of the string - 1, and repeats the first i characters until it matches the length of the original. Then, it compares this value to the original and computes whether any of them are true.
I don't know/remember how many characters Infinity counts as, so if that's a problem, I have an 88 character solution without any special chars:
```
Block[{v=Characters@#}, 
Or@@Table[
    PadRight[v~Take~i,Tr[1^v],v~Take~i]==v,{i,Tr[1^v]-1}]]&
```
This converts the string into a list and saves it as a variable, which costs 24 characters, but makes the rest far shorter. I can't just define v as a global variable since that messes up the pure function, and writing out Characters@# is far too long to not be a variable.
[Answer]
# [Factor](https://factorcode.org/) + `grouping.extras math.unicode sequences.repeating`, 59 bytes
```
[ dup head-clump 1 head* [ over length cycle = ] with ‚àÉ ]
```
[Try it online!](https://tio.run/##7VJNT8MwDL3vV5gNEB9iStK0aUFIKxfEhQviNE0oy0xX0aUlbYGh3bjwO/kjxd0ATeK6XRCy/Ww/W8855F6bKnfN7c3V9eUpPKCzmEHi8rpIbdLHl8rpEkp8rNEaLCFBi05n6auu0tyuTfoOCyTSJjDT1bRf29TkE4TCYVXNC5faCs46nW4cdwku4rGmvDPo7e7tHxzeHe@0bGwI9XhlywU9NhMkWPFGj7EtB4se2YB8QdgCtcRzRrZytpaW8QNf/Poa@8W0Ykp6QcSFWoZgvgoDxQNPhO2ElpTkIYXyZCh4wFRrPGSSIAo8qQQPfSUDriJfChX6XDFPCu4rwbgX@tLbkrjYjNSWXteGVH4kufAjQcV2znyfEJuX/P8Yf@hjdJshTOoCpqgnJyarZwXwZXMEQ8if0EGGNqmmYOYmQziHETyn1H68v8Go4QysLopsDv0SaK5d8wk "Factor ‚Äì Try It Online")
## Explanation
```
                         ! "abba"
dup                      ! "abba" "abba"
head-clump               ! "abba" { "a" "ab" "abb" "abba" }
1 head*                  ! "abba" { "a" "ab" "abb" }
[ over length cycle = ]  ! "abba" { "a" "ab" "abb" } [ over length cycle = ]
with                     ! { "a" "ab" "abb" } [ "abba" [ over length cycle = ] swapd call ]
```
`‚àÉ` Alias for `any?` -- Does the quotation return `t` for any elements in the sequence? Inside the quotation now for the first element...
```
                         ! "abba" "a"
over                     ! "abba" "a" "abba"
length                   ! "abba" "a" 4
cycle                    ! "abba" "aaaa"
=                        ! f
```
Second element
```
                         ! "abba" "ab"
over                     ! "abba" "ab" "abba"
length                   ! "abba" "ab" 4
cycle                    ! "abba" "abab"
=                        ! f
```
Third
```
                         ! "abba" "abb"
over                     ! "abba" "abb" "abba"
length                   ! "abba" "abb" 4
cycle                    ! "abba" "abba"
=                        ! t
```
[Answer]
# [Japt](https://github.com/ETHproductions/japt) [`-d`](https://codegolf.meta.stackexchange.com/a/14339/), 6 [bytes](https://en.wikipedia.org/wiki/ISO/IEC_8859-1)
```
W¬∂√ÆV√ÆW
```
[Try it](https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&flags=LWQ&code=V7buVu5X&input=IkB8I3wjfEAjfEB8fEAjQHx8QHwjfCI)
[Answer]
# [Canvas](https://github.com/dzaima/Canvas), 9 [bytes](https://github.com/dzaima/Canvas/blob/master/files/chartable.md)
```
ÔºªÔºõÔº¨ÔΩç‚â°ÔºΩÔΩã‚àë‚Äº
```
[Try it here!](https://dzaima.github.io/Canvas/?u=JXVGRjNCJXVGRjFCJXVGRjJDJXVGRjREJXUyMjYxJXVGRjNEJXVGRjRCJXUyMjExJXUyMDND,i=YWJjZGVh,v=8)
Can remove `‚Äº` to save a byte if *any* truthy output (not necessarily consistent) is allowed.
]