[Question]
  [
An palindrome is a word that is its own reverse.
Now there are some words that might look like palindromes but are not. For example consider the word `sheesh`, `sheesh` is not a palindrome because its reverse is `hseehs` which is different, however if we consider `sh` to be a single letter, then it's reverse is `sheesh`. This kind of word we will call a semi-palindrome.
Specifically a word is a semi-palindrome if we can split up the word in to some number of chunks such that when the order of the chunks are reversed the original word is formed. (For `sheesh` those chunks are `sh e e sh`) We will also require no chunk contains letters from both halves of the word (otherwise every word would be a semi-palindrome). For example `rear` is not a semi-palindrome because `r ea r` has a chunk (`ea`) that contains letters from both sides of the original word. We consider the central character in an odd length word to be on neither side of the word, thus for words with odd length the center character must always be in it's own chunk.
Your task will be to take a list of positive integers and determine if they are a semi-palindrome. Your code should output two consistent unequal values, one if the input is a semi-palindrome and the other otherwise. However the byte sequence of your code ***must be a semi-palindrome*** itself.
Answers will be scored in bytes with fewer bytes being better.
## Test-cases
```
[] -> True
[1] -> True
[2,1,2] -> True
[3,4,2,2,3,4] -> True
[3,5,1,3,5] -> True
[1,2,3,1] -> False
[1,2,3,3,4,1] -> False
[11,44,1,1] -> False
[1,3,2,4,1,2,3] -> False
```
[Program to generate more testcases.](https://tio.run/##bZDBCoMwDIbvPsWP7KDIXkDoDhu7D3YUGdVVLNZ2qw4ve3eXqhXZFgJp/iRf2ta8a4RS41ghTRGdn@Ax2AEZz7H/DkdjVFCBo0CWA4xOjKHw0i3fSupUv3QDO4eoskb3SFHGAd6@SK1LnaFCNvUQ2FtW8LLZ5GSl0L2wDmH6WthBdsKXHGJdMy@IES38JFlo8YoYaF4EK5PmpZY9Sie51gmpeOekQHZX0coLV1LfrWnF39@a/uenc3paTj62XGpKH1bSHXdeRmhs4TwcPw "Haskell – Try It Online")
---
[borrible](https://codegolf.stackexchange.com/users/2046/borrible) pointed out that these are similar to [generalized Smarandache palindromes](https://planetmath.org/generalizedsmarandachepalindrome). So if you want to do some further reading that's one place to start.
  
[Answer]
# [Retina 0.8.2](https://github.com/m-ender/retina/wiki/The-Language/a950ad7d925ec9316e3e2fb2cf5d49fd15d23e3d), ~~85~~ 69 bytes
```
M`^(.+,)*(\d+,)?(?<-1>\1)*$(?(1)^)|M`^(.+,)*(\d+,)?(?<-1>\1)*$(?(1)^)
```
[Try it online!](https://tio.run/##K0otycxL/K@q4Z7w3zchTkNPW0dTSyMmBUjZa9jb6BraxRhqaqlo2GsYamrYK2pq1hCl6v9/LkMdAx1DHS5jHRMdIyAE0UCOKVAURAKlQWKGMAZIGsQx0DExAGsEAA "Retina 0.8.2 – Try It Online") Explanation:
```
M`
```
Selects Match mode. In fact, Retina defaults to Match mode for a single-line program, but the second copy of the code would always match if not for these extra characters.
```
^
```
Match must start at the beginning.
```
(.+,)*
```
Capture a number of runs of characters. Each run must end in a comma.
```
(\d+,)?
```
Optionally match a run of digits and a comma.
```
(?<-1>\1)*
```
Optionally match all of the captures in reverse order, popping each one as it is matched.
```
$
```
Match must end at the end.
```
(?(1)^)
```
Backtrack unless all of the captures were popped. It works by requiring the match to still be at the start of the string if we have an unpopped capture, which is impossible.
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), ~~27~~ 23 bytes
```
ṖUṁ@Ƒ€ṚẸHḢŒŒHḢŒṖUṁ@Ƒ€ṚẸ
```
Returns **1** for semi-palindromes, **0** otherwise.
[Try it online!](https://tio.run/##y0rNyan8///hzmmhD3c2Ohyb@KhpzcOdsx7u2uHxcMeio5OOToLQWBT8P9wOZAORgvv//9FcCsoKJUWlJRmVCiWpxSUKyYnFqcVcCtHRsToK0YYgwkjHUMcIxDDWMdExAkIgDeGaAmWAZGysDsiUtMScYnRDDMHKwcZAmCAzIFxDHRMgEyZnDJQFcYFqoMYVp@akgU0DmqNOjj/VgebEAgA "Jelly – Try It Online")
### How it works
```
ṖUṁ@Ƒ€ṚẸHḢŒŒHḢŒṖUṁ@Ƒ€ṚẸ  Main link. Argument: A (array)
          Œ              Invalid token. Everything to its left is ignored.
           ŒH            Halve; divide A into two halves similar lengths. The middle
                         element (if there is one) goes into the first half.
             Ḣ           Head; extract the first half.
              ŒṖ         Generate all partitions of the first half.
                U        Upend; reverse each chunk of each partition.
                         Let's call the result C.
                     Ṛ   Yield R, A reversed.
                   Ƒ€    Fixed each; for each array P in C, call the link to the left
                         with arguments P and R.
                         Return 1 if the result is P, 0 if not.
                 ṁ@          Mold swapped; replace the n integers of C, in reading
                             order, with the first n integers of R.
                     Ẹ   Exists; check if one of the calls returned 1.
```
[Answer]
# [Python 2](https://docs.python.org/2/), ~~157~~ ~~153~~ ~~147~~ 143 bytes
-4 bytes thanks to [tsh](https://codegolf.stackexchange.com/users/44718/tsh).
```
s=lambda x,i=0:len(x)<2or[]<x[i:]and(x[-i:]==x[:i])&s(x[i:-i])|s(x,i+1)
s=lambda x,i=0:len(x)<2or[]<x[i:]and(x[-i:]==x[:i])&s(x[i:-i])|s(x,i+1)
```
[Try it online!](https://tio.run/##K6gsycjPM/r/v9g2JzE3KSVRoUIn09bAKic1T6NC08Yovyg61qYiOtMqNjEvRaMiWhfIsrWtiLbKjNVUK9YAyegCmTVApk6mtqEmF5XM@V9QlJlXolCsER2ryQVnG@oY6BgiCxjrmOgYASGQRhU2BaoEkqiaQeoMMYVAhgCF/wMA "Python 2 – Try It Online")
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), ~~59~~ ~~47~~ ~~43~~ 41 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
```
2äøø€.œ`âʒ`RQ}gĀIg_^q2äøø€.œ`âʒ`RQ}gĀIg_^
```
-12 bytes thanks to *@Emigna*.
[Try it online](https://tio.run/##yy9OTMpM/f/f6PCSwzsO73jUtEbv6OSEw4tOTUoICqxNP9LgmR4fV4hX9v//aGMdEx0jHQMgBrJiAQ) or [verify all test cases](https://tio.run/##yy9OTMpM/V9Waa@k8KhtkoKSfaVL6H@jw0sO7zi841HTGr2jkxMOLzo1KSEosDb9SENEenzcf53/0dGxOgrRhjoGOoYghrGOiY4REAJpCNcUKAMkIYpA4oYIJgiaIAsYgYyBsMCCBjomBjCTQVYg80CqTSCqY2MB).
**Explanation:**
```
2ä               # Split the input into two parts
                 #  i.e. [3,4,2,0,2,3,4] → [[3,4,2,0],[2,3,4]]
  øø             # Zip twice without filler
                 # This will remove the middle item for odd-length inputs
                 #  i.e. [[3,4,2,0],[2,3,4]] → [[3,2],[4,3],[2,4]] → [[3,4,2],[2,3,4]]
    €.œ          #  Then take all possible partitions for each inner list
                 #   i.e. [[3,4,2],[2,3,4]]
                 #    → [[[[3],[4],[2]],[[3],[4,2]],[[3,4],[2]],[[3,4,2]]],
                 #       [[[2],[3],[4]],[[2],[3,4]],[[2,3],[4]],[[2,3,4]]]]
`                # Push both lists of partitions to the stack
 â               # Take the cartesian product (all possible combinations) of the partitions
                 #  i.e. [[[[3],[4],[2]],[[2],[3],[4]]],
                 #        [[[3],[4],[2]],[[2],[3,4]]],
                 #        ...,
                 #        [[[3,4,2]],[[2,3,4]]]]
  ʒ   }          # Filter this list of combinations by:
   `             #  Push both parts to the stack
    RQ           #  Check if the second list reversed, is equal to the first
                 #   i.e. [[3,4],[2]] and [[2],[3,4]] → 1 (truthy)
       gĀ        # After the filter, check if there are any combinations left
                 #  i.e. [[[[3,4],[2]],[[2],[3,4]]]] → 1 (truthy)
         Ig_     # Check if the length of the input was 0 (empty input-list edge-case)
                 #  i.e. [3,4,2,0,2,3,4] → 7 → 0 (falsey)
            ^    # Bitwise-XOR
                 #  i.e. 1 XOR 0 → 1 (truthy)
             q   # Stop the program (and then implicitly output the top of the stack)
2äøø€.œ`âʒ`RQ}gĀIg_^
                 # Everything after the `q` are no-ops to comply to the challenge rules
```
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 37 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
Utilizes roughly the same technique [Jonathan](https://codegolf.stackexchange.com/a/174095/59487) came up with.
```
.œʒ€gηOZ;îå}εÂQ}ZĀqĀZ}QÂε}åî;ZOηg€ʒ.œ
```
[Try it online!](https://tio.run/##AU4Asf9vc2FiaWX//y7Fk8qS4oKsZ863T1o7w67DpX3OtcOCUX1axIBxxIBafVHDgs61fcOlw647Wk/Ot2figqzKki7Fk///WzExLDQ0LDEsMV0 "05AB1E – Try It Online")
---
```
.œʒ€gηOZ;îå}εÂQ}ZĀqĀZ}QÂε}åî;ZOηg€ʒ.œ
```
Full program. Receives a list from STDIN, outputs **1** or **0** to STDOUT.
```
.œʒ        }
```
Filter-keep the partitions that satisfy...
```
   €gηOZ;îå
```
This condition: The lengths of each (`€g`) are stored in a list, whose prefixes (`η`) are then summed (`O`), hence giving us the cumulative sums of the lengths list. Then, the ceiled halve of the maximum of that list is pushed onto the stack – but keeping the original list on it as well (`Z;î`) and if it occurs (`å`) in the cumulative sums then the function returns truthy.
```
εÂQ}
```
For each, compare (`Q`) **a** with **a** reversed, which are pushed separately on the stack by `Â`. Returns a list of **0**s and **1**s.
```
ZĀq
```
Maximum. If any is truthy, then **1** else **0**. End execution. Everything that follows is completely ignored.
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), ~~33~~ 32 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
-1 Thanks to Erik the Outgolfer  
Thanks also to Dennis for a bug fix and looking into changing an implementation detail in Jelly.
```
ẸƇŒḂƇƊ$ƊĊHṀċÄẈṖŒŒṖẈÄċṀHĊƊ$ƊƇŒḂƇẸ
```
Semi-palindromes yield `1`, others yield `0`.
**[Try it online!](https://tio.run/##y0rNyan8///hrh3H2o9Oerij6Vj7sS6VY11Hujwe7mw40n245eGujoc7px2dBJTdOQ3IOdxypBso5XGkC6wQrg1oxP///6ONdYx1THRMdcx0wKxYAA "Jelly – Try It Online")** (slow as it's \$O(2^n)\$ in input length)
Or see the [test-suite](https://tio.run/##y0rNyan8///hrh3H2o9Oerij6Vj7sS6VY11Hujwe7mw40n245eGujoc7px2dBJTdOQ3IOdxypBso5XGkC6wQrg1oxP@jew63P2paA1I6A0gDkfv//9HRsQpIQFlB107BkEsn2lDHQMcwFl3UWMdExwgIgXQssqgpUDWQjEU1AaQOagZY1AAuCjLHMBZJ1EDHxABmI1Q0FgA "Jelly – Try It Online").
The only chunks are the `ŒḂ`s ({3rd & 4th} vs {29th & 30th} bytes), just to allow the code to parse.
### How?
All the work is performed by the right-hand side - the "Main Link":
```
ŒṖẈÄċṀHĊƊ$ƊƇŒḂƇẸ - Main Link: list
ŒṖ               - all partitions
           Ƈ     - filter keep those for which this is truthy (i.e. non-zero):
          Ɗ      -   last three links as a monad:
  Ẉ              -     length of each
         $       -     last two links as a monad:
   Ä             -       cumulative addition
        Ɗ        -       last three links as a monad:
     Ṁ           -         maximum
      H          -         halve
       Ċ         -         ceiling
    ċ            -     count
              Ƈ  - filter keep those for which this is truthy:
            ŒḂ   -   is palindrome?
               Ẹ - any?
```
[Answer]
# [Perl 6](https://github.com/nxadm/rakudo-pkg), ~~87~~ 79 bytes
*-8 bytes with some tricks from Jo King's answer*
```
$!={/\s/&&/^(.+)\s[(.+)\s]*$0$/&&$1.$!}#$!={/\s/&&/^(.+)\s[(.+)\s]*$0$/&&$1.$!}
```
[Try it online!](https://tio.run/##K0gtyjH7n1upoJamYPtfRdG2Wj@mWF9NTT9OQ09bM6Y4GkLFaqkYqACFVQz1VBRrlYlU99@aqzixUiFNQyVeUyEtv4hLQ1OHS8NQx0DHEMQw1jHRMQJCIA3hmgJlgCREEUjcEMEEKYZwDXRMDMBGWP8HAA "Perl 6 – Try It Online")
Port of tsh's JavaScript answer. Returns two different Regex objects.
[Answer]
# [Python 2](https://docs.python.org/2/), ~~275~~ ~~251~~ 205 bytes
-24 bytes thanks to @KevinCruijssen
-44 bytes thanks to @PostLeftGhostHunter
-2 more bytes thanks to @KevinCruijssen
```
def s(x):
 l=len(x)
 if l<2:return 1>0
 for i in range(1,l/2+1):
	if x[l-i:]==x[:i]:return s(x[i:l-i])
def s(x):
 l=len(x)
 if l<2:return 1>0
 for i in range(1,l/2+1):
	if x[l-i:]==x[:i]:return s(x[i:l-i])
```
Returns True for semi-palindrome, None otherwise
[Try it online!](https://tio.run/##vY1BCgIxDEXX9hRZzmDFadVNsV6kdCHYaqBkhlqhnr5mFoqDewkkn5f/k@lZbiPp1i4hwr2rvRGQbArEUgBGSEdtciiPTKBOg4A4ZkBAgnyma@iUTFu9Vhxbsbm6tEHjra3OoH/n@KxDwxvfi/@8aVNGKkwcv/xoJQepvsFO7qXm4rnEB3ZyX4Znn/pF8xHG7QU "Python 2 – Try It Online")
[Answer]
# [Ruby](https://www.ruby-lang.org/), 129 bytes
```
f=->l{!l[1]||(1...l.size).any?{|x|l[0,x]==l[-x,x]&&f[l[x..~x]]}}#f=->l{!l[1]||(1...l.size).any?{|x|l[0,x]==l[-x,x]&&f[l[x..~x]]}}
```
[Try it online!](https://tio.run/##KypNqvyfZlvAVWxrYxMc4h@gl5yRXwAU0bXLqVbMiTaMranRMNTT08vRK86sStXUS8yrtK@uqajJiTbQqYi1tc2J1q0AMtTU0qJzoiv09OoqYmNra5UpNeA/yC1cqWWJOQrFXFwFCmnR0bGxENpQx0DHEMYx1jHRMQJCII0QMgWqAJIIDSB5Q1QuSCNICCxWHPsfAA "Ruby – Try It Online")
[Answer]
# [JavaScript (Node.js)](https://nodejs.org), 139 bytes
```
f=a=>(s=(''+a).replace(/^(.*),((.*),)?\1$/,'$3'))!=a?f(s):/,/.test(s)//^(.*),((.*),)?\1$/,'$3'))!=a?f(s):/,/.test(s)f=a=>(s=(''+a).replace(
```
[Try it online!](https://tio.run/##lY3dDoIwDIXveQsTkrVaNyZ4Ixlc@RSIyYLDnxBG2OLr4xATr7wwTU6/0560D/3Urhnvg9/29mKmqVVaFeAUMLbRyEczdLoxIM7A10jwVixPMhbE4pQhrpQuW3B4ECS4N84HFv/Ff/yc8iqqaooqSQnJGVLKaBcq9MXuwyboEprn8otzeLEJZcnnRM1bOx51cwOvisb2znaGd/YKLXhEzKcX "JavaScript (Node.js) – Try It Online")
[Answer]
## [C (gcc)](https://gcc.gnu.org/) (X86), 216 bytes
```
p(L,a,n)int*a;{return n?(memcmp(a,a+L-n,n*4)|p(L-2*n,a+n,L/2-n))&&p(L,a,n-1):1<L;}
#define p(L,a)p(L,a,L/2)//p(L,a,n)int*a;{return n?(memcmp(a,a+L-n,n*4)|p(L-2*n,a+n,L/2-n))&&p(L,a,n-1):1<L;}
#define p(L,a)p(L,a,L/2)
```
[Try it online!](https://tio.run/##vZNRa6NAFIXf8yvuWhIcM26a1G6hJg2lpFDwYaktLGRDmeqkFXQUxyyBbH579s41TQzmecGH8Z7v3nNmRiP3I4p2u8IOuOCKJapyhL8pZbUqFaipncksygpbcNEPXMWV47G/CLsjR2FJ8WAwchVjvd5@gjtkt8Nx4G87F7FcJkoCCayWkWaDwX80210kKkpXsYSxruL3PE@/f951TopJ3iqlybupdXQlqiQC0wYiTd8KoTVMoCpX0j@of/Ikhkrqysb9QCoVB7MQc1wu@L5ZaQabDtRvpTRTvhU2wYL5X8J@PukT04QucHTuTYigYlGiydK2uhrmFq87p2D9vA9DC27Berx/CixGaJQrXUH0KUpwYpkmGVpYFknLvASK7ayxKHxYwxgE9M02fOj313Xqpl03Rjsaw7GLsgMcxnKwTGXbjLgA9w66@rdC1WwNY5oTpJhLkWppcmKHyZGJRNm1KR3pJad88wXbbDkdPDmSNjxqw5Z4dRRHHBAdtZAfRwRpDxF6zLrFXp@w1zTRLFqg1wj1Nc6ko42e9T5gdYgzcHMm0p5H9mfAm5OpVzS4ho1Dg8eG/V93@LimMPv19PIWvj48zMIQ74ZezWf0@jzD@9n9Aw "C (gcc) – Try It Online")
`p(L,a,n)` returns 0 if array `a` of length `L` is a semi-palindrome, 1 otherwise. Given that all prefixes of length `>n` are already checked, it compares the prefix of length `n` with the suffix of length `n`. `p(L,a)` is the entry point.
Unfortunately, the more interesting solution is longer:
## 224 bytes
```
(f(L,a,n))//#define p(L,a)(n=L/2,
int*a,n;
{return n?(memcmp(a,a+L-n,n*4)|f(L-2*n,a+n,L/2-n))&&f(L,a,n-1):1<L;}//{return n?(memcmp(a,a+L-n,n*4)|f(L-2*n,a+n,L/2-n))&&f(L,a,n-1):1<L;}
int*a,n;
#define p(L,a)(n=L/2,f(L,a,n))//(
```
[Try it online!](https://tio.run/##rZNRa6NAFIXf/RV3LQmjGTeb1O5CTRpKyULBh6W2sJANZarjVtBR1CyBbH579s41jQbzuODDeO93zzkzo6HzOwwPBxYznwuuLGs8vopknCgJhS5ZTM398ZQbiaptBDxjV8p6UypQC5bJLMwKJrgY@Y7iynatvyjkTG2FJcVx0EHJ4fCo7kys28nM9/bj8f9QaTNdjNzZEjtcJSpMN5GEWVVHb3mefn6/M86KSd4rpcmbrhlVLeokBD0GIk1fC1FVMIe63Ejv1P2TJxHUsqoZxoJUKg56IVa4XPPjsKos2BnQvJVSq3wqGMHC8j4aR33qz/UQukDrPJwTQcWiRJOYmYMKViZvJhdg/rgPAhNuwfx@/@ibFqFhrqoawndRgh3JNMnQwjSpFeclUGx7i0XhwRZmIGCkt@HBaLRtUnftBhHakQzHKcoOcJLlYOrKvhtxDc4dDKpfCrt6axhTnyDFjEVaSZ0TJ3SOTCSKNaZ0pF845Vutrd2e08GTI/UmbW/Sa163zSkHRKc95GuLIO0iQo9e99ibM/aGFPWiB7qdUB9yOh1t9KL3CWtCXIC7mki7LtlfAL@dqV6TcANrhw6PA8f/8PRxLWD58/H5NXh5eFgGAd4NverP6OVpifdz@Ac "C (gcc) – Try It Online")
Ungolfed:
```
(f(L,a,n)) //#define p(L,a)(n=L/2,
int*a,n;
{
  return n 
    ? (memcmp(a, a+L-n, n*4) | f(L-2*n, a+n, L/2-n)) &&
      f(L,a,n-1)
    : 1 < L;
} // { ... } 
int*a,n;
#define p(L,a)(n=L/2,f(L,a,n)) //(
```
[Answer]
# [Japt](https://github.com/ETHproductions/japt), 66 bytes
```
@¯X eUsXn}a1 "
Ê§V?UÊ<2:ßUéV sVÑ
@¯X eUsXn}a1 "
Ê§V?UÊ<2:ßUéV sVÑ
```
[Japt Interpreter](https://ethproductions.github.io/japt/?v=1.4.6&code=CkCvWCBlVXNYbn1hMSAiCsqnVj9VyjwyOt9V6VYgc1bRCkCvWCBlVXNYbn1hMSAiCsqnVj9VyjwyOt9V6VYgc1bR&input=W1tdLApbMV0sClsyLDEsMl0sClszLDQsMiwyLDMsNF0sClszLDUsMSwzLDVdLApbMSwyLDMsMV0sClsxLDIsMywzLDQsMV0sClsxMSw0NCwxLDFdLApbMSwzLDIsNCwxLDIsM10sCls0NDEsMiwxNDRdXQotbQ==)
Big improvement this version, it actually beats most of the practical languages now. Now operates on an array of integers since the previous method had a bug.
Explanation:
```
@        }a1         Find the first number n > 0 such that...
 ¯X                   the first n elements
     UsXn             and the last n elements
    e                 are the same
"
Ê§V?UÊ<2:ßUéV sVÑ    String literal to make it a Semi-palindrome
@¯X eUsXn}a1 "
Ê§V?                 If n >= length of input...
    UÊ<2              return true if the length is less than 2
        :            Otherwise...
          UéV         move n elements from the end of the input to the start
              sVÑ     remove the first 2*n elements
         ß            and repeat on the remaining elements
```
[Answer]
# [Perl 6](https://github.com/nxadm/rakudo-pkg), 81 bytes
```
($!={/../&&/^(.+)(.*)$0$/&&$1.$!})o&chrs#($!={/../&&/^(.+)(.*)$0$/&&$1.$!})o&chrs
```
[Try it online!](https://tio.run/##K0gtyjH7n1upoJamYPtfQ0XRtlpfT09fTU0/TkNPW1NDT0tTxUAFyFcx1FNRrNXMV0vOKCpWJlbhf2uu4sRKhTQNlXhNhbT8Ii4NTR0uDUMdAx1DEMNYx0THCAiBNIRrCpQBkhBFIHFDBBOkGMI10DExgBqhTnUnq@vlF6UUW/8HAA "Perl 6 – Try It Online")
Returns the regex `/../` for True and the regex `/^(.+)(.*)$0$/` for False. Works similarly to [nwellnhof's answer](https://codegolf.stackexchange.com/a/174113/76162), but converts the list to a string beforehand.
[Answer]
# [Brachylog](https://github.com/JCumin/Brachylog), 21 bytes
```
ḍ{|b}ᵗ~cᵐ↔ᵈḍ{|b}ᵗ~cᵐ↔
```
[Try it online!](https://tio.run/##SypKTM6ozMlPN/pfXa6koGunoFRuX/2obcOjpuZHHcuVSopKU/WUakDMtMScYiC79uGuztqHWyf8f7ijt7omCcicXpcM5D9qm/Jwawem4P//0dGxOtGGQGykY6hjBKSNdUx0jIAQSIN5pkBxIAlSBRY1hLNAKsE8Qx0TIAsqYwyUA/GAKmJjAQ "Brachylog – Try It Online")
```
ḍ              Split the input in half, with the second half longer if uneven.
 {|b}ᵗ         Maybe remove the first element of the second half.
      ~cᵐ      Partition both halves.
         ↔ᵈ    Is it possible for one to be the other's reverse?
ḍ{|b}ᵗ~cᵐ↔     The remainder of the program always succeeds.
```
[Answer]
# PHP 237 bytes
```
function f($a){for($x=2>$c=count($a);++$i<=$c/2;)$x|=($s=array_slice)($a,0,$i)==$s($a,-$i)&f($s($a,$i,-$i));return$x;}#function f($a){for($x=2>$c=count($a);++$i<=$c/2;)$x|=($s=array_slice)($a,0,$i)==$s($a,-$i)&f($s($a,$i,-$i));return$x;}
```
recursive function, returns `true` (for input containing less than two elements) or `1` for truthy,  
`0` for falsy. [Try it online](http://sandbox.onlinephpfunctions.com/code/e2b41433d385050941b71dd63216e6051a62c958) (contains breakdown).
Actual code length is 118 bytes;
semi-palindrome created via code duplication.
For better performance, replace `&` with `&&` and insert `!$x&&` before `++$i`.
[Answer]
# Scala, 252 bytes
```
def^(s:Seq[Int]):Int={val l=s.size;if(l>1)(1 to l/2).map(i=>if(s.take(i)==s.takeRight(i))^(s.slice(i,l-i))else 0).max else 1}//def^(s:Seq[Int]):Int={val l=s.size;if(l>1)(1 to l/2).map(i=>if(s.take(i)==s.takeRight(i))^(s.slice(i,l-i))else 0).max else 1}
```
[Try it online!](https://tio.run/##xU7BCsIwDL37FTm2MDc3PU068OhVj@KgblGrsau2yHDs22vUj5DAy8t7vCS@0aRjd7hgE6AD7APa1sPKORhii8da@HKL993ahr0sGdXw1ASkfOrNC5fmKKjKpcghdEBZIdObdsKoig2fBn1FYaRSP7oxp3PgWfLW1JNp2ExoygKSR5h9wj18eT5m2V/PR/cwNpAVteAHxDxZJAUXdynlZIxv "Scala – Try It Online")
PS. Apparently, solution is 2 times longer just to satisfy a requirement that source code is semi palindrome as well.
PPS. Not a code-golf candidate but purely functional solution using pattern matching:
```
  def f(s:Seq[Int], i:Int=1):Int = {
    (s, i) match {
      case (Nil ,_) => 1
      case (Seq(_), _) => 1
      case (l, _) if l.take(i) == l.takeRight(i) => f(l.slice(i,l.size-i), 1)
      case (l, j) if j < l.size/2 => f(l, i+1)
      case (_, _) => 0
    }
  }
```
]