[Question]
  [
An alphadrome is a word in which each letter in the first half of the word "reflects" its alphabetical "opposite" in the second half of the word. Write a program or function that returns truthy if the given word is an alphadrome and falsey otherwise.
For example, `BEEB` is a palindrome. Its first letter `B` "reflects" its last letter `B`, and its second letter `E` reflects its second-to-last letter `E`.
In contrast, `BEVY` is an ***alphadrome***. Its first letter `B` is the second letter of the alphabet, and it reflects the word's last letter `Y`, which is the second-to-last letter of the alphabet. Likewise, its second letter `E` is the 5th letter of the alphabet, and it reflects `V`, the 5th-from-the-end letter of the alphabet.
Like palindromes, an alphadrome can have an odd number of letters, too. `WORLD` is an alphadrome. `W` is the 4th-from-the-end letter of the alphabet and `D` is the 4th letter; `O` is the 12th-from-the-end letter of the alphabet and `L` is the 12th letter. The center `R` reflects itself.
Any single-letter word is an alphadrome.
## Rules
* Input words will include only the characters `a-z` *or* `A-Z`, whichever is convenient.
* Output will be a [truthy or falsey value](https://codegolf.meta.stackexchange.com/questions/2190/interpretation-of-truthy-falsey).
* [Default I/O rules](https://codegolf.meta.stackexchange.com/questions/2447/default-for-code-golf-input-output-methods/) apply, [standard rules](https://codegolf.meta.stackexchange.com/questions/2419/default-for-code-golf-program-function-or-snippet/2422#2422) apply, and [standard loopholes](https://codegolf.meta.stackexchange.com/questions/1061/loopholes-that-are-forbidden-by-default) are forbidden.
* This is code golf. Shortest answer in bytes wins.
## Test cases
```
A        true
ABA      false
ABZ      true
ABBA     false
BEVY     true
GOLF     false
ZOLA     true
WIZARD   true
BIGOTRY  true
RACECAR  false
ABCDEFGHIJKLMNOPQRSTUVWXYZ  true
```
  
[Answer]
# [J](http://jsoftware.com/), 25 24 bytes
```
[:*/155=3,~inv@(+|.)@u:]
```
[Try it online!](https://tio.run/##y/pvqWhlGGumaGWprs6lpKeepmBrpaCuoKNgoGAFxLp6Cs5BPm7/o6209A1NTW2Ndeoy88ocNLRr9DQdSq1i/2ty@TnpKRhr6TtogORjYRJcqckZ@QqGCrYKaQrqjuoQrgGU6wQTgMk7RaGrQFfi5BoWiarG3d/HDVVNlL8Pmq5wzyjHIBc0kzzd/UOC0AwLcnR2dXYMQneWs4urm7uHp5e3j6@ff0BgUHBIaFh4RGSU@n8A "J – Try It Online")
*-1 thanks to ovs*
Based on the observation that this is essentially just requiring that the sum of the ascii codes of the input and its reverse add to 155.
The only exception is that, in the odd case, the middle element can be anything. The inverse of self-append in J `,~inv` returns the first half of a list, but "rounds down" in the odd case, and so does what we need.
That is, we can take the sums of the ascii codes as described, take the `,~inv` of that result, and check if they are all 155.
[Answer]
# [Python 3](https://docs.python.org/3/), 58 bytes
```
f=lambda s:len(s)<2or ord(s[0])+ord(s[-1])==155*f(s[1:-1])
```
[Try it online!](https://tio.run/##LY5NC4JAEEDv/YrFy7qlkEUXyWD9zLKszTQVD4ZJgqm4Xvr1pm6nN294A9N8u3ddrfs@V8r088xSQOXyVfEUbVd1C@o242m8TNCCTaKUIEWRNpt5Ppgkj97nQ0hBUYEYYigAiNU/IgamquGHIy3XMUdGrjPtAzvCRJ8K23I9MkUEa4aGCbvXdMO09vbh6JzO7uVKbt7dDx5hBBN5Bpq2qDqeCpy44wQwfIVQ/wM "Python 3 – Try It Online")
Takes lowercase letters as input.
*-3 bytes thanks to pxeger*
[Answer]
# Excel (ms365), ~~147~~, ~~111~~, ~~110~~, ~~98~~ 89 bytes
-15 bytes thanks to [@jdt](https://codegolf.stackexchange.com/users/41374/jdt)  
-4 bytes thanks to [@EngineerToast](https://codegolf.stackexchange.com/users/38183/engineer-toast)
```
=LET(l,LEN(A1),n,SEQUENCE(l/2),IF(l>1,SUMSQ(CODE(MID(A1,n,1))+CODE(RIGHT(A1,n))-155),)=0)
```
| A | B |
| --- | --- |
| A | TRUE |
| ABA | FALSE |
| ABZ | TRUE |
| ABBA | FALSE |
| BEVY | TRUE |
| GOLF | FALSE |
| ZOLA | TRUE |
| WIZARD | TRUE |
| BIGOTRY | TRUE |
| RACECAR | FALSE |
| ABCDEFGHIJKLMNOPQRSTUVWXYZ | TRUE |
Uploading a small screenshot was not possible at time of posting. Also, the byte-count is high and I'm eager to see if fellow Excel enthusiasts can bring this down.
[Answer]
# [Vyxal](https://github.com/Vyxal/Vyxal), ~~8~~ 7 bytes
```
Ḃ+⁺6oLṅ
```
[Try it Online!](https://vyxal.pythonanywhere.com/#WyJBIiwiZkMiLCLhuIIr4oG6Nm9M4bmFIiwiIiwiQVxuQUJBXG5BQlpcbkFCQkFcbkJFVllcbkdPTEZcblpPTEFcbldJWkFSRFxuQklHT1RSWVxuUkFDRUNBUlxuQUJDREVGR0hJSktMTU5PUFFSU1RVVldYWVoiXQ==)
-1 thanks to a trick from @Kevin Cruijssen's 05AB1E answer.
[Answer]
# [C (clang)](http://clang.llvm.org/), ~~53~~ 44 bytes
-9 bytes thanks to [c--](https://codegolf.stackexchange.com/users/112488/c)!!!
```
f(*s,*e){return--e<=s||*s+*e==155&f(s+1,e);}
```
[Try it online!](https://tio.run/##dVFNb4JAEL3zKyY0NruAqTbxUuSAimil0lLrZzkYnG1IKBoW06bqb6eLFtO0Moed2Tfz8uYjqAbRMn7LMkYUrilIdwmm2ySuVrFp8P1e4aqChlFvNK4Z4WpdQ6ofsqsVsjBGcKyhPeqRKQXCwy9cM8jjGzh/FjWfUkkK4xTel2FMKEg7CYQJRIEUebrwwYATlpsjm7Im3jTZoqz9hlunBFtG/G9mXkYp5bSs8ewyyXadbglp7jolzU36c9PrXM61@rY78krUPLNttU2vdLJ2x@ravf79wHkYuo9P3vPoZTyZzv4NfNCPjq0TIPmyQ7HUmi5cs7hRvmuaI6oBt/QssklEOSNyJeKCUllpgJ8bDFJc3YHAXmOhdDxT6GvASBH@ePUj4BHGBUxpUQwq1H2qS4fsGw "C (clang) – Try It Online")
[Answer]
# [Raku](https://raku.org/), 37 bytes
```
{155==all .ords[^(*+>1)]Z+.flip.ords}
```
[Try it online!](https://tio.run/##HYrdCoIwGEBf5UMkKkHwwm5qxvzNslbLNBclQg2ChaJXIj77Wl0cOBxO82rFQn56mHBAcrBsG6FKCDDr9tndHtO54VizOzNMLt7NP45y2VU9aHoJyIFhzUEvRw143cIKA3Z/MIUSN8gKiEgSAiMJhjxmmPrgxhFJaQEUe4GHqVo9PwijTbzdJfsDOZ7oOb1k@bVgjvwC "Perl 6 – Try It Online")
* `.ords` is a string method that returns a list of Unicode codepoints.
* `^(* +> 1)` is an anonymous function that returns a list of numbers from 0 to one less than the argument shifted one bit to the right. (`* div 2` would be more readable, but is longer.)
* When a list is subscripted with a function, the list's length is passed to the function, and whatever the function returns is used to index into the list. Most often this is used to index from the end of the list (eg `@list[* - 1]`) but here, the result is a slice of the first half of the list, not including the middle element, if any.
* `.flip` is a string method that returns the reverse of the original string. `.flip.ords` is thus the list of the input string's Unicode codepoints in reverse order.
* `Z+` zips the two lists of codepoints with addition, up to the length of the shorter list.
* `155 == all ...` is a junction which is truthy if all of the added codepoints are equal to 155.
[Answer]
# x86-64 machine code, 16 bytes
```
AC 83 EF 02 78 09 02 04 3E 3C 9B 74 F3 31 C0 C3
```
[Try it online!](https://tio.run/##VVJtb9owEP5s/4pbJoTdpB3qpn2AMYlSyljp2LKuL7x8CI4TXAWnio0Wivjry86hq9Yvd7675zk9z8niOBWiqiKzBgahx@hJmuXLKIOEJm2S5bFZUmI2S5CxCuCUkgcDkpIojiHKApgVRoEPRawWlIj1Y91s9pp@c9pErMQ1pMwLkFEZuEBlmxTSUu4B71ClLSTMRWSJXBsLYhUVcGRwSN8qLbJNLOGTsbHKT1afX7UKpVPXo/8TrZgtoAs76vW8AMPZc5oe0qE8G9zcuzycjC9cnk7Gdf92NO2F5zViNJxchzUo7PUH/V544PfPBxfDL6Ovl@Orb5PvP8Kf179ubu/u3fY9KnZO1pHSjNMdJQn6rs0pVNTqYHrTBaOeZJ4wK/i75ydq5jj0fU4JssgrO8hES2rRwcEjOrYJ8xpmbhtqrr0AbID3w1NkUjPLseZ4OLKnL9i5vorESmmJ541l23NjJ6l0kgLYYhnnsPsHh0br9A73bruMbbRRqZZxLeWIJ3xW@v6Cd/bwe6UyCWzr/LTK/nu39GUDayhYbq00vFZY4nBfVX9EkkWpqY7XHz9gwO/WRbzM/gI "C (gcc) – Try It Online")
Following the standard calling convention for Unix-like systems (from the System V AMD64 ABI), this takes the length of the string in EDI and its address in RSI, and returns a value in EAX, nonzero if and only if the string is an alphadrome.
In assembly:
```
f:  lodsb               # Load a byte from the string into AL, advancing the pointer.
    sub edi, 2          # Subtract 2 from the length in EDI.
    js e                # Jump to the end if the result is negative.
                        #  In this case, the string is an alphadrome.
                        #  AL (which is the low byte of EAX) is nonzero.
    add al, [rsi + rdi] # Add the opposite-positioned byte in the string to AL.
    cmp al, 'A'+'Z'     # Compare the sum with the sum of 'A' and 'Z'.
    je f                # Jump back, to repeat, if they are equal.
    xor eax, eax        # If not, the string is not an alphadrome. Set EAX to 0.
e:  ret                 # Return.
```
[Answer]
# [Raku](https://github.com/nxadm/rakudo-pkg), 35 bytes
```
{2>grep *-155,(.ords Z+[R,] .ords)}
```
[Try it online!](https://tio.run/##Vc3NCoJAFIbhfVdxVqFlkoHtFMbfLMuaTHPEhZBGYCljERFdu2Ea1tm9PB@cIqHZtDo/oJ@CBNVzIh9pUsBgJIgix/A5PZRAhiHmIvgE@6rK@AEpw4fjiAVJBj4UIkhzCtnpkpSyzN/rXYWgvSu9JT2ktJ3GWVkn@cNWG1R0L@jQdGzjB4ljow59iyCsfUuxTMfFQVsYqbqKcPdS1XTDnFnzhb1cOesN3ro7z98HpNm/AQ "Raku – Try It Online")
Anonymous code block that takes a string and returns a boolean.
# Explanation
```
{2>grep *-155,(.ords Z+[R,] .ords)}
{                                 }  # Anonymous code block
              (.ords Z           )   # Zip the codepoints of the string
                      +                # Adding them
                       [R,]            # To the reverse
                            .ords      # of the codepoints
   grep *-155,                       # From this, filter out the 155s
 2>                                  # And check if there is exactly 1 or 0 of them
```
[Answer]
# [R](https://www.r-project.org), ~~34~~ ~~35~~ 24 bytes
*Edit: +1 byte to fix bug spotted by Kamil Drakari*  
*Edit2: saved 11 bytes by changing to same approach as [my Nibbles answer](https://codegolf.stackexchange.com/a/253115/95126)*
```
\(x)sum(x+rev(x)!=155)<2
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m72waMHazOLEnIKMxJSi_NxU26WlJWm6FjtiNCo0i0tzNSq0i1LLgGxFW0NTU00bI4j0zafIejSAYhYh-Z55JRpKjkqamly4JJ1cwyLxyYd7RjkGueA1wdPdPyQIryGOTk54HeHu7-OGTz7I0dnV2TEIpATi2QULIDQA)
Input is vector of codepoints.
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 8 bytes
```
+Un155SỊ
```
[Try it online!](https://tio.run/##y0rNyan8/187NM/Q1DT44e6u/w93b/E/3P6oac3RPUBmFpDxqGGOgo2twqOGuZH//ztyOTqBcBQQAxlOrmGRXO7@Pm5cUf4@jlzhnlGOQS5cTp7u/iFBkVxBjs6uzo5BQKXOLq5u7h6eXt4@vn7@AYFBwSGhYeERkVEA "Jelly – Try It Online")
-1 thanks to Jonathan Allan
[Answer]
# [Perl 5](https://www.perl.org/), 49 bytes
```
sub f{pop=~/.\K.*\B/?155-ord($`)-ord$'?0:f($&):1}
```
[Try it online!](https://tio.run/##ZZFdT4MwFIbv@RUnCxMw7EszYyALwj5wbg5F3ITsQt2KkrHRActclvnXsRQWh/am7dun5317ilHoN5Mk2ryDu8cBbn3XqtNB9Xyq1ZRGs1kJwjnPvgrpzHJKXXJ59kyQGodkuYObGEUxtGC95RkgQ4V8xOEGZYqWa@6bHx0l5x@UU7@Q1h3bRUg3hr0/kGMM1SI06Tuq2TlVtL5uWKZ9ophqu9tWzWKkwqbd6fb02/7dYHg/Mh4ezSfreTx5sZ28iCAz20/PRzx9vrCnt5Y7nvVWWGTRFxZISyLsezNECbEuXsg5BOxHkHbMpbQACnBpTQ4k4GgELiNx6K1iF0rlynUEhNzEEpQrl/WInBEHNIvRPFWuUoGUzNbTVUlkjn@QJgG0zhyJT7CgLiPDAmPAiUDjUkqkjMwckh8 "Perl 5 – Try It Online")
[Answer]
# [JavaScript (Node.js)](https://nodejs.org), 34 bytes
*-1 and a bug fixed thanks to [@l4m2](https://codegolf.stackexchange.com/users/76323/l4m2) (on both versions)*
Expects an array of ASCII codes. Returns *true* for non-alphadrome or *false* for alphadrome.
```
a=>a.some((_,i)=>a.pop()+a[i]-155)
```
[Try it online!](https://tio.run/##rdK7CsIwFIDh3aeomRK0KQ6OCunFWq1W470iEmoilWpKq75@xUFwsGgxZzvLz8fhnNid5VEWp1f9Ig@8EJ2CdboM5/LMIdw3Y/TcUplC1GDbeKe32m1URPKSy4TjRB5hXcAtxti8CcEzLDJ5hoAArWzQDiHNMLRrduO1rx2ztPTqCJbkv4RCoAZUKqoGMp3lBigAuYHfUwIKA5@oAK28kFAb/N0xPTeY0483qtShxHIsQoGCF7Jsp@f2vcHQH42DyZTO5ovlar0JwTuoeAA "JavaScript (Node.js) – Try It Online")
---
# [JavaScript (Node.js)](https://nodejs.org), 51 bytes
Expects a string. Returns *true* for non-alphadrome or *false* for alphadrome.
```
s=>(a=[...Buffer(s)]).some((_,i)=>a.pop()+a[i]-155)
```
[Try it online!](https://tio.run/##ndG7DoIwGIbh3avATm3UGgdHSMpRFEXrAcUY02BrMGgJFW8fBwcHxQT//c2TL/@FPZhKijS/927yxCuhV0o3INP3GGOzFIIXUKEDwkpeOYTHbop0g@Fc5hB12D499AbDIaoSeVMy4ziTZ9gWEBCg1R1CWr@v3YuStz4qs7Z7VYJl6lsWg3@wWu0XZjqbHWiMeWHg/oHFYUCaY5EfE2qDhpXpe@GKft32o6LEcixCQeOXWbbjeiN/PAmms3C@oMvVehNtdzF4Y9UT "JavaScript (Node.js) – Try It Online")
[Answer]
# [Pyth](https://github.com/isaacg1/pyth), 14 bytes
```
!t-+VJCMz_J219
```
[Try it online!](https://tio.run/##K6gsyfj/X7FEVzvMy9m3Kt7LyNDy///yzKrEohQA "Pyth – Try It Online")
### Explanation:
```
     JCMz         assign input codepoints to J and return list
         _J       reverse J
   +V             map addition over two lists
  -        219    remove all instance of 219 from this list
!t                list has no more than 1 element
```
[Answer]
# [Haskell](https://www.haskell.org/), 54 bytes
```
f s=[1]<[1|(x,y)<-zip<*>reverse$fromEnum<$>s,x+y/=219]
```
[Try it online!](https://tio.run/##lZDLDoIwEEX3fsXEsPABMbgzoez8CsKiQAuVQnFaXo3/jgtjooYu3M7JyZ17K6prJuWycNAkCdMoCR@7yZ/3UWBFFx1iZANDzTyOqrm2fRN5sfan43wi5/CSLg0VLRAo1AY6FK0BDzhs6RaCAAz27PucvQCnUv8S61KcTsaGeV0qleQOySrpeG4UlmKxzjJRKoOONKQ5yyk6m@UF42UlbrVsWtXdUZt@GKf5o/B7/Jj8t/4T "Haskell – Try It Online")
Zip input with its reverse, there can be at most one pair not summing to 219, the one in the centre of an odd lengthy string.  
So by yielding *1* for unbalanced pairs we must have a list less or equal than [1]
Saved a byte by inverting the output and using greater than [1]
[Answer]
# [Fig](https://github.com/Seggan/Fig), \$9\log\_{256}(96)\approx\$ 7.408 bytes
```
M'>2Lo155+$
```
[Try it online!](https://fig.fly.dev/#WyJNJz4yTG8xNTUrJCIsIltbNjVdLFs2NSw2Niw2NV0sWzY1LDY2LDkwXSxbNjUsNjYsNjYsNjVdLFs2Niw2OSw4Niw4OV0sWzcxLDc5LDc2LDcwXSxbOTAsNzksNzYsNjVdLFs4Nyw3Myw5MCw2NSw4Miw2OF0sWzY2LDczLDcxLDc5LDg0LDgyLDg5XSxbODIsNjUsNjcsNjksNjcsNjUsODJdLFs2NSw2Niw2Nyw2OCw2OSw3MCw3MSw3Miw3Myw3NCw3NSw3Niw3Nyw3OCw3OSw4MCw4MSw4Miw4Myw4NCw4NSw4Niw4Nyw4OCw4OSw5MF1dIl0=)
(link includes extra code for test cases)
[Answer]
# [Wolfram Language (Mathematica)](https://www.wolfram.com/wolframscript/), 52 bytes
```
Count[ToCharacterCode@#//#+Reverse@#&,Except@155]<2&
Count[#+Reverse@#&@*ToCharacterCode@#,Except@155]<2&   
(*   52 bytes too,using @*    diff is just "@*" and "//"    *)
```
[Try it online!](https://tio.run/##TcvNCoJAFIbh/VxFjOCmQgrcVTiOP1mWNpmm4WKwEV2YYVME0bWbmUhn93C@t6A8YwXleULrdF7j8n7hJ6/EGa1owlmFyzNTBEkShoQ9WHVrII70Z8KuXJnIcjybirVb5U0kjBepIsSipLwARHA06K6B2vOL6B/9C0BV98MepmMbPSLH7mYABlaEiNaqSSzT8UhbAUgQ1jEiPyAVa7phLq3V2t5sHXdH9t7BD45hBMG7/gA "Wolfram Language (Mathematica) – Try It Online")
**I'm new to codegolf, any suggestion will be appreciated.**
The code means, convert string to charactercode list, add it with its reversal, count number of element!=155, judge whether the number is less than 2.
one interesting thing is that, among 26 letter, there's no letter such that CharacterCode==155/2
**so this algorithm is absolutely true for input string formed from 26 upper letters**
[Answer]
# [Nibbles](http://golfscript.com/nibbles/index.html), 7.5 bytes (15 nibbles)
```
- 2,|!\$@+%155
```
Input is array of codepoints.
All positive integers are truthy in [Nibbles](http://golfscript.com/nibbles/index.html), zero and negative integers are falsy.
```
- 2,|!\$@+%155
     !          # zip together
      \$        # the reverse of the input
        @       # and the input
         +      # by addition,
    |           # then filter the list
                # to keep only truthy elements upon
          %155  # modulo 155,
   ,            # get the length of the resulting list,
- 2             # and subtract it from 2
                # (so only zero or one non-155 element
                # will give a truthy >0 output)
```
[![enter image description here](https://i.stack.imgur.com/NNeUT.png)](https://i.stack.imgur.com/NNeUT.png)
[Answer]
# [Japt](https://github.com/ETHproductions/japt), ~~14~~ 13 [bytes](https://en.wikipedia.org/wiki/ISO/IEC_8859-1)
```
cÈ+UÔcYÃk'Û Å
```
[Try it](https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&code=Y8grVdRjWcNrJ9sgxQ&input=WwoiYSIsCiJhYmEiLAoiYWJ6IiwKImFiYmEiLAoiYmV2eSIsCiJnb2xmIiwKInpvbGEiLAoid2l6YXJkIiwKImJpZ290cnkiLAoicmFjZWNhciIsCiJhYmNkZWZnaGlqa2xtbm9wcXJzdHV2d3h5eiIKXS1tUg)
Takes input as a lowercase string. Outputs an empty string for `true` and a non-empty string for `false`.
```
cÈ+UÔcYÃk'Û Å
cÈ            # Map the charcode of each input character through:
   UÔcY       #  Get the charcode at the same index in the input reversed
  +           #  Add them together
       Ã      # Treat the results as charcodes for a new string
        k'Û   # Remove the character "Û" whenever it appears
            Å # Remove the first remaining character if possible
              # Implicitly print the result
```
[Answer]
# [Ruby](https://www.ruby-lang.org/), 44 bytes
```
f=->w{/.(.*)./!~w||w.sum-$1.sum==155&&f[$1]}
```
[Try it online!](https://tio.run/##KypNqvz/P81W1668Wl9PQ09LU09fsa68pqZcr7g0V1fFEETZ2hqamqqppUWrGMbW/rexiY@P18vJzEst1stNLKiuqagpUIhOi66I1o8p19aPjdVRSC1LzNGA8FX0YzVja7kcFaCgpKg0lcvRCcpPS8wpBnGjUCShshBJJ9ewSISku7@PG5JklL@PI0Iy3DPKMcgFxnPydPcPCYqE8oIcnV2dHYMQVjq7uLq5e3h6efv4@vkHBAYFh4SGhUdERkHVA/34HwA "Ruby – Try It Online")
[Answer]
# [Japt](https://github.com/ETHproductions/japt), 11 [bytes](https://en.wikipedia.org/wiki/ISO/IEC_8859-1)
Input as an array of lowercase codepoints, outputs `false` for truthy & `true` for falsey.
```
£v +UoÃd-#Û
```
[Try it](https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&header=rG1j&code=o3YgK1Vvw2QtI9s&footer=IVY&input=WwoiYSIKImFiYSIKImFieiIKImFiYmEiCiJiZXZ5IgoiZ29sZiIKInpvbGEiCiJ3aXphcmQiCiJiaWdvdHJ5IgoicmFjZWNhciIKImFiY2RlZmdoaWprbG1ub3BxcnN0dXZ3eHl6IgpdLW1S) (includes all test cases, footer reverses output)
```
£v +UoÃd-#Û     :Implicit input of charcode array U
£               :Map
 v              :  Remove & return first element of U
   +            :  Add
    Uo          :  Remove & return last element of U
      Ã         :End map
       d        :Any truthy
        -       :  Subtract
         #Û     :  219
```
[Answer]
# C# (.Net 6), 73 bytes
```
int i=0;while(i<s.Length/2)if(s[i++]+s[^i]!=155)return false;return true;
```
[Try it here](https://dotnetfiddle.net/OlXEMU)
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), 7 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
```
ÇÂ+ƵsKg!
```
Input as a list of capital codepoint-integers (although could alternatively be in lowercase as well by changing `s` to `\`). Outputs an 05AB1E truthy result (`1`) if it's an alphadrome, and an 05AB1E falsey result (in this case any other integer) if it's not.
[Try it online](https://tio.run/##yy9OTMpM/X@4/f/hJu1jW4u90xX//w/3D/JxAQA) or [verify all test cases](https://tio.run/##yy9OTMpM/V9TVmn/qGGegoZ95eF2eyVNhUdtkxSUQJz/h5u0j20t9k5X/O9in6mkoFFSVJqqqXR4NZCZlphTDGTX6vx35HJ0AuEoIAYynFzDIrnc/X3cuKL8fRy5wv2DfFy4wj2jHINcuJw83f1DgiK5ghydXZ0dg4AanF1c3dw9PL28fXz9/AMCg4JDQsPCIyKjAA).
**Explanation:**
```
Â        # Bifurcate the (implicit) input-list; short for Duplicate & Reverse copy
 +       # Add the values at the same positions in the lists together
  Ƶs     # Push compressed integer 155
    K    # Remove all 155 from the list
     g   # Pop and push the length
      !  # Get the factorial of this length
         # (0 becomes 1; 1 remains 1; any other integer just increases)
         # (which is output implicitly as result)
```
[See this 05AB1E tip of mine (section *How to compress large integers?*)](https://codegolf.stackexchange.com/a/166851/52210) to understand why `Ƶs` is `155` (and `Ƶ\` is `219`).
[Answer]
# [Pip](https://github.com/dloscutoff/pip), ~~23~~ 17 bytes
*-6 bytes thanks to DLosc!*
```
#(_!=155FIg+Rg)<2
```
[Try It Online!](https://dso.surge.sh/#@WyJwaXAiLCIiLCIjKF8hPTE1NUZJZytSZyk8MiIsIiIsIiIsIjY2IDczIDcxIDc5IDg0IDgyIDg5Il0=)
Takes in input as a list of codepoints in the arguments. Port of the R answer, so make sure to upvote that too!
```
#(_!=155FIg+Rg)<2     ; Input = list of codepoints = g
#(            )       ; Get the length of...
          g+Rg        ; the vectorized sum of g and its reverse...
  _!=155FI            ; filtered by if each element is not equal to 155...
               <2     ; and test if the length is less than 2
                      ; (after which the result is implicitly printed out)
```
[Answer]
# [sed](https://www.gnu.org/software/sed/) `-E`, ~~103~~ 102 bytes
*-1 byte thanks to [user41805](https://codegolf.stackexchange.com/users/41805/user41805)*
```
:a
s/./\L&/
y/abcdefghijklmnopqrstuvwxyz/ZYXWVUTSRQPONMLKJIGHFEDCBA/
/../!cT
T
s/^(.)(.*)\1$/\2/
ta
cF
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m724ODVlWbSSrqtS7IKlpSVpuhY306wSuYr19fRjfNT0uSr1E5OSU1LT0jMys7JzcvPyCwqLiktKy8orKqv0oyIjwsNCQ4KDAgP8_Xx9vL083T3cXF2cnRz1ufT19PQVk0O4QoBmxWnoaWroaWnGGKroxxjpc5UkciW7QWyDWrrgpr8jl6MTCEcBMZDh5BoWyeXu7-PGFeXv48gV7hnlGOTC5eTp7h8SFMkV5Ojs6uwYBFTq7OLq5u7h6eXt4-vnHxAYFBwSGhYeERkFMRcA)
[Answer]
# [Factor](https://factorcode.org/) + `math.unicode`, ~~35~~ 29 bytes
```
[ halves reverse v+ ""⊂ ]
```
[Try it online!](https://tio.run/##S0tMLskv@h8a7OnnbqVQnFpYmpqXnFqskJtYkqFXlgqSLFbITi3KS82BiJXmZSbnp6QqFBSllpRUFhRl5pUoWHNxVXMpAIGSo5ICbqCoUFJUmgpV6IRHqaJCWmJOMVxllBKRRuIxE8VIJ9ewSCVijHT393Ejzsgofx9HoowM94xyDHJRIqzQydPdPyQIhzuRFQY5Ors6OwYpEROUzi6ubu4enl7ePr5@/gGBQcEhoWHhEZGgEIYaWcv1P1ohIzGnDJgIilLLUouKUxXKtBWUDs1WetTVpBD7PzexQKG4JDE5W@8/AA "Factor – Try It Online")
```
             ! "BIGOTRY"
halves       ! "BIG" "OTRY"
reverse      ! "BIG" "YRTO"
v+           ! { 155 155 155 }
""           ! { 155 155 155 } { 155 }   (string with non-printable char 155)
⊂           ! t     (subset?)
```
[Answer]
# [Go](https://go.dev), ~~104~~ 73 bytes
```
func f(s string)bool{l:=len(s)
return l<2||s[0]+s[l-1]==155&&f(s[1:l-1])}
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m70oPX_BzoLE5OzE9FSF3MTMPK7M3IL8ohI9pbTcEqWlpSVpuhY3PdNK85IV0jSKFYpLijLz0jWT8vNzqnOsbHNS8zSKNbmKUktKi_IUcmyMamqKow1itYujc3QNY21tDU1N1dSA-qINrUACmrUQA28xKYNNBNmnoalQzZVtZZumoeSopMkVADS_JCcPxNHJ1ikpKk3Vyba1BdGaXNlgRU6oypzACtMSc4rBKsEMuNIoVKVROM1ENxSPqU6uYZHIisF87Oa6-_u4ISsF83GZG-Xvg-IIMB-7ueGeUY5BLsiKoSLYlTt5uvuHBKE6GiqEXUOQo7Ors2MQsgaYEO6wdnZxdXP38PTy9vH18w8IDAoOCQ0Lj4hEiwKcqjBcAk0rCxZAaAA)
Based on [@Manish Kundu's answer](https://codegolf.stackexchange.com/a/253089/77309)
* -31 bytes by @Jordan, @Steffan: Combining the `if`s into a single expression
[Answer]
# [Retina 0.8.2](https://github.com/m-ender/retina/wiki/The-Language/a950ad7d925ec9316e3e2fb2cf5d49fd15d23e3d), 49 bytes
```
T`L`RL`^.(.)*(?!(?<-1>.)*$)
+`^(.)(.*)\1$
$2
^.?$
```
[Try it online!](https://tio.run/##FYrBCgIhFADv7y8CA91I2M7Roq5rlmWZ7aaE2KFDlw7R/5sdBoZhPs/v6/0oc6xy8dlkZ3KimJIGdzPcrZftpjoisMipVkwbcm8RoBUk2qFSGDD@J1aqcDkGUNYMEK1hMOnIXA9cK@tdAMeEFMzVVfRyUFu925vD0Z7O7uKv43QL8Qc "Retina 0.8.2 – Try It Online") Link includes test cases. Explanation:
```
T`L`RL`^.(.)*(?!(?<-1>.)*$)
```
Transliterate the first half of the word, flipping between `A-Z` and `Z-A`.
```
+`^(.)(.*)\1$
$2
^.?$
```
Test whether this results in a palindrome. (This turns out to be the same method as @ovs's answer to [Shortest code to determine if a string is a palindrome](https://codegolf.stackexchange.com/q/11155/) so I might have remembered the approach.)
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 15 bytes
```
⬤∕θ²⁼⌕αι⌕⮌α§⮌θκ
```
[Try it online!](https://tio.run/##S85ILErOT8z5/z@gKDOvRMMxJ0fDJbMsMyVVo1BHwUhTR8G1sDQxp1jDLTMvRSNRRyETKARmB6WWpRYVp2okAgUcSzzzUlIr4GKFQLFsTRCw/v8/3DPKMcjlv25ZDgA "Charcoal – Try It Online") Link is to verbose version of code. Outputs a Charcoal boolean, i.e. `-` for an alphadrome, nothing if not. Explanation:
```
  θ             Input string
 ∕ ²            First half (excluding middle character if any)
⬤               All characters satisfy
     ⌕          Index of
       ι        Current character
      α         In predefined variable uppercase alphabet
    ⁼           Equals
        ⌕       Index of
             θ  Input string
            ⮌   Reversed
           §    Indexed by
              κ Current index
          α     In predefined variable uppercase alphabet
         ⮌      Reversed
                Implicitly print
```
[Answer]
# [Behaviour](https://github.com/FabricioLince/BehaviourEsolang), ~~40~~ 37 bytes
```
~(a*=ascii\:i<-#a/2a%i+a%(-i-1)~=155)
```
`a` must contain input string
```
a = "ABA"
@~(a*=ascii\:i<-#a/2a%i+a%(-i-1)~=155)
```
ungolfed and commented:
```
~(              // invert the result of the following sequence
  a *= ascii    // convert string input to a list of ascii values
  \:i <- #a/2   // iterate from 0 to half the input size
    a%i+a%(-i-1)~=155   // stop if opposites values don't sum to 155
)
```
[Answer]
# [Julia 1.0](http://julialang.org/), ~~50~~ ~~48~~ ~~44~~ 41 bytes
```
~x=sum((a=Int[x...]).+reverse(a).!=155)<2
```
[Try it online!](https://tio.run/##LYvBCoJAAETvfcW2ICjJQoIdIqHVzCxL20xT8@DBYqO20Iw9@euW2unNPGZu1Z1mY940NdfK6iGKmWazd8IRQqmERkX@yYsyFzMJDbWxqkozpalKyq7AKyh7XwbJ/NUFEQrKpJwCgZ4ZlAGXQc0lcHkWgAPKQALxz0Ks/xH36KtuBlFLy3WWLWPX6Xxox5gsuoVtuT7pRgQbpoFJ/zcW5tJa2euNs9253p4c/GMQnqIYpmnzBQ "Julia 1.0 – Try It Online")
Saved 2 bytes thanks to Sʨɠɠan's suggestion: use the return value of the variable assignment.
Saved 4 bytes thanks to amelies: replace `collect(x)` with `[x...]`.
Saved 3 bytes thanks to MarcMush: replace `Int.([x...])` with `Int[x...]`.
]