[Question]
  [
### Your task
Given a string of lowercase letters, output the "alphabet checksum" of that string, as a letter.
### Example
Let's say we have the string *"helloworld"*. With `a = 0`, `b = 1`, `c = 2` ... `z = 25`, we can replace all of the letters with numbers:
```
h  e  l  l  o  w  o  r  l  d
7  4  11 11 14 22 14 17 11 3
```
Now, we can sum these:
```
7+4+11+11+14+22+14+17+11+3 = 114
```
If we mod this by 26, we get:
```
114 % 26 = 10
```
Now, using the same numbering system as before, get the 10th letter, `k`. This is our answer.
### Test cases
```
Input          Output
helloworld     k
abcdef         p
codegolf       h
stackexchange  e
aaaaa          a
```
**This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so shortest code in bytes wins.**
  
[Answer]
# Excel (ms365), ~~59~~, 58 bytes
-1 Thanks to [@TheThonnu](https://codegolf.stackexchange.com/users/114446/the-thonnu)
```
=CHAR(MOD(SUM(CODE(MID(A1,SEQUENCE(LEN(A1)),1))+7),26)+97)
```
[![enter image description here](https://i.stack.imgur.com/Cd5An.png)](https://i.stack.imgur.com/Cd5An.png)
[Answer]
# [JavaScript (Node.js)](https://nodejs.org), 51 bytes
```
s=>(B=Buffer)([B(s).map(c=>t+=c+7,t=0)|97+t%26])+''
```
[Try it online!](https://tio.run/##Zc69DoIwFAXg3adoSAxtqmAcJA5l4DWMQ73cglK5hNafwXevEtABz/zlnHPRd@2gP3d@3VKJwajgVM4LVdyMwV7wQ8GdSK6646ByLxXIbOXVRrz2mfTL7e4oZBwHoNaRxcRSxQ2ParSWHtTbMmKMCcHSlDWLGdInKNEMgP1QN0fwOVWRndiI6jlyXkODT6h1W2E0IvybG/Jdm5p0eAM "JavaScript (Node.js) – Try It Online")
[Answer]
# [MATL](https://github.com/lmendo/MATL), 10 bytes
```
2Y2j97-sQ)
```
[Try it online!](https://matl.io/?code=2Y2j97-sQ%29&inputs=helloworld&version=22.7.4) Or [verify all test cases](https://tio.run/##y00syfmf8N8o0ijL0ly3OFDzv0vI/4zUnJz88vyinBSuxKTklNQ0ruT8lNT0/Jw0ruKSxOTs1IrkjMS89FSuRBAAAA).
### Explanation
```
2Y2j97-sQ)
2Y2         % Push predefined literal: string 'abc···xyz'
            % STACK: 'abc···xyz'
   j        % Take input as a string
            % STACK: 'abc···xyz', 'helloworld'
    97-     % Push 97 (ASCII code of 'a'), and subtract element-wise
            % STACK: 'abc···xyz', [7 4 11 11 14 22 14 17 11 3]
       s    % Sum
            % STACK: 'abc···xyz', 114
        Q)  % Add 1, and use as index (1-based, modular). Implicit display
            % STACK: 'k'
```
[Answer]
# [Go](https://go.dev), 68 bytes
```
func(s string)(t int){for _,r:=range s{t+=int(r)-97}
return t%26+97}
```
[Attempt This Online!](https://ato.pxeger.com/run?1=hY9NasMwEIX3OoUQBCSSdNFF_kC7HCA3KIosOSayFGbGScH0JNmYQu_TrW8TOfHamc0wzON9791_y9T1_GLs2ZSO16aKrKovCehD-JoEuxrgqP8a8stNv_dNtBI5ElSxVJJ4FUm1PgH_WsBOg4nZBFua6_yQoJbb9Q8DRw1ETrPP1Tzfo9f_4PUESsVbhjstTi6EdEsQCsEOmUAhSlyMNOklKqUYamGOtnB-WmNT4coU3qiQcnH3bU9D8DfQYSYkY6-ue-0H)
[Answer]
# [brainfuck](https://github.com/TryItOnline/brainfuck), ~~142~~ 126 bytes
```
,[>++++++++[-<------------>]<-[->>>>+<<<<],]>>>>>+++++[->+++++<]>+<<[>+>->+<[>]>[<+>-]<<[<]>-]>>>>++++++++[-<++++++++++++>]<+.
```
[Try it online!](https://tio.run/##TYxdCoAwDIMPtNUTlF6k9MFfFIeDgXj8Gp3Ivpe0SZuh9NuxnOPuHlXChxJTgxiTkoDAwKLJu9TTqmxPiAqBATVRxmzwEJH9D7U@NKA@dO7rnFK@cknTDQ "brainfuck – Try It Online")
Edit: -16 bytes due to common sense. Remembered I didn't have to load 97 into its own cell before adding/subtracting.
My first time golfing in brainfuck! Here's the ungolfed code for your viewing displeasure:
```
,					GET EACH CHARACTER IN THE INPUT
[
	>++++++++[-<------------>]<-	SUBTRACT 97 (8 TIMES 12 PLUS 1) FROM CELL 0
	[->>>>+<<<<]			ADD CELL 0 TO CELL 4
	, 				INPUT TO CELL 0
]
>>>>					GO TO CELL 4
>+++++[->+++++<]>+<<			LOAD 26 (5 TIMES 5 PLUS 1) INTO CELL 6
[>+>->+<[>]>[<+>-]<<[<]>-]		TAKE CELL 4 MOD CELL 6
>>>					GO TO RESULT IN CELL 7
>++++++++[-<++++++++++++>]<+		ADD 97 (8 TIMES 12 PLUS 1) TO CELL 7
.					DISPLAY
```
[Answer]
# [R](https://www.r-project.org/) v4.2.0, 63 59
*-4 thanks to Dominic van Essen*
```
\(x,l=letters)l[(sum(match(el(strsplit(x,"")),l)-1)%%26)+1]
```
The input string `x` is parsed as characters, and `match` is used to retrieve the index of each character in the `letters` builtin, minus one to convert from 1-based to 0-based.
[Answer]
# [Gaia](https://github.com/splcurran/Gaia), ~~16~~ 15 bytes
```
⟨c97%⟩¦Σ26%97+c
```
[Try it online!](https://tio.run/##S0/MTPz//9H8FcmW5qqP5q88tOzcYiMzVUtz7eT//4tLEpOzUyuSMxLz0lMB "Gaia – Try It Online")
Pretty standard implementation of what the challenge asks.
I was able to save a byte thanks to the golfing advice given by  
Dominic van Essen!
## Explained
```
⟨c97%⟩¦Σ26%97+c
⟨    ⟩¦           # To each letter in the input {
 c97%            #  modulo the character code by 96
                 #  }
       Σ26%      # Get the sum of that list and modulo 26
          97+c   # and add 97 to turn it back into an ascii letter
```
[Answer]
# Mathematica, ~~60~~ 48 bytes
```
FromLetterNumber[Tr[LetterNumber@#-1]~Mod~26+1]& 
```
[View it on Wolfram Cloud!](https://www.wolframcloud.com/obj/ec33c9bc-7802-4cb5-ace8-cd76d01dae4e)
*-12 bytes thanks to [JSorngard](https://codegolf.stackexchange.com/users/88906/jsorngard)!*
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), 6 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
```
ADIkOè
```
Input as a list of characters.
[Try it online](https://tio.run/##yy9OTMpM/f/f0cUz2//wiv//o5UylHSUUoE4B4rzgbgcShdBxVKUYgE) or [verify all test cases](https://tio.run/##yy9OTMpM/V9Waa@k8KhtkoKSfWVw6H9Hl4hs/8Mr/uv8j1bKSM3JyS/PL8pJUdJRSkxKTklNAzKS81NS0/NzQMziksTk7NSK5IzEvPRUkBoQUIoFAA).
**Explanation:**
```
A       # Push the lowercase alphabet
 D      # Duplicate it
  I     # Push the input-list
   k    # Get the index of each character in the (top) alphabet
    O   # Sum these together
     è  # (Modular 0-based) index it into the alphabet
        # (after which this character is output as result)
```
[Answer]
# [Factor](https://factorcode.org/) + `math.unicode`, ~~25~~   24 bytes
```
[ 7 v+n Σ 26 mod 97 + ]
```
-1 byte thanks to some black magic from Arnauld!
[Try it online!](https://tio.run/##JYtBDoIwFET3nGJC4orEhQuJegDjxo1xhSzq7y8lQgttARPjabyPV6qis5iXSd4oQcG6eD4djvstlHWtCKE2Fb7Uv1oOpiYr@T9Gnn2PfoLnfmBD7LFLkn56QHPT2Mm6RkJcSbLC/Ktso@CDoBvfSQtTMcQcPGOBHGNm8H5htUZrJTY5MpSxFR0KpAu6mBSdq01QKMGCdPwA "Factor – Try It Online")
```
     ! "helloworld"
7    ! "helloworld" 7
v+n  ! { 111 108 115 115 118 126 118 121 115 107 }
Σ    ! 1154
26   ! 1154 26
mod  ! 10
97   ! 10 97
+    ! 107
```
[Answer]
# [Python 3](https://docs.python.org/3/), 43 bytes
-1 byte from @Arnauld
```
lambda s:chr(sum(ord(c)+7for c in s)%26+97)
```
[Try it online!](https://tio.run/##BcFBCoAgEADAr3gJd/FWkBT0ky6miYK6shrR622mfj1QWYY/zpFMvpwRbbeBoT0ZiB1YVNoTCytiEQ2neVWbxlE5lg4eZLhTopc4OYk4fg "Python 3 – Try It Online")
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 8 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
```
O+7S‘ịØa
```
A monadic Link that accepts a list of characters and yields a character.
**[Try it online!](https://tio.run/##y0rNyan8/99f2zz4UcOMh7u7D89I/P//f3J@Smp6fk4aAA "Jelly – Try It Online")** Or see the [test-suite](https://tio.run/##y0rNyan8/99f2zz4UcOMh7u7D89I/P9w95bD7Y@a1kT@/58BlM8vzy/KSeFKTEpOSU3jSs5PSU3Pz0njKi5JTM5OrUjOSMxLT@VKBAEA "Jelly – Try It Online").
### How?
```
O+7S‘ịØa - Link: list of characters, Message
O        - ordinals (Message)
 +7      - add seven (vectorises)
   S     - sum
    ‘    - increment
      Øa - "abc...xyz"
     ị   - index into (1-based and modular)
```
[Answer]
# [jq](https://stedolan.github.io/jq/), 37 bytes
```
explode|map(.-97)|[add%26+97]|implode
```
[Try it online!](https://tio.run/##yyr8/z@1oiAnPyW1JjexQENP19JcsyY6MSVF1chM29I8tiYzFyz7/39Gak5Ofnl@UU4KV2JSckpqGlcyUDw9PyeNq7gkMTk7tSI5IzEvPZUrEQT@5ReUZObnFf/XDQIA "jq – Try It Online")
[Answer]
# [Raku](https://raku.org/), 27 bytes
```
{chr sum(.ords X-97)%26+97}
```
[Try it online!](https://tio.run/##FcHRCoJAEAXQX7mIRhH10IMipN/Rm6y7My40NjFblIjfvtE5TzKp87xgx@jy6qMhvef9WS0k3E5tc6gu9bFttpzcgqIc0PVYGeWwFWA1XCOJ6EdNAtzoAzG8BppUGOnl/J2@PrrHRHB/ff4B "Perl 6 – Try It Online")
[Answer]
# [Nibbles](http://golfscript.com/nibbles/index.html), 7 bytes (14 nibbles)
```
+%+.$-$;'a'26 
```
```
   .            # map over 
    $           # the input:
     -          #   subtract
        'a'     #   the letter 'a'
       ;        #   (and save it)
      $         #   from each letter
                #   (which gives its 0-based index)
  +             # now sum this list
 %         26   # apply modulo-26
+               # and add back the saved letter 'a'
```
[![enter image description here](https://i.stack.imgur.com/YvD1C.png)](https://i.stack.imgur.com/YvD1C.png)
[Answer]
# [K (ngn/k)](https://codeberg.org/ngn/k), ~~16~~ 14 bytes
```
`c$97+26!+/97!
```
[Try it online!](https://ngn.codeberg.page/k#eJxLs0pIVrE01zYyU9TWtzRX5OJKi1bKSM3JyS/PL8pJUYoF8ROTklNS0yDs5PyU1PT8HCivuCQxOTu1IjkjMS89FaoYBJRiAZ5hG88=)
*-2 bytes thanks to coltim!*
Explanation:
```
`c$97+26!+/97!  Main function. Takes implicit input
           97!  Modulo by 97 to each character in the string
                to convert them into the 0..25 system
                (In K, every character in a string is also an ASCII charcode)
         +/     Sum
      26!       Modulo by 26
   97+          + 97 to each of them to convert them back to ASCII charcode
`c$             And convert them back to characters
```
[Answer]
# [Julia 1.0](http://julialang.org/), ~~36~~ 26 bytes
```
!s=sum([s...].-'a')%26+'a'
```
[Try it online!](https://tio.run/##HY1BDoIwEEX3nGKYYGwjNtGFO05CXNR2gEptCQORePlaeJv/Fi/579U7fdtSKrnh9SNaVko91fWsz/J0f1zypi7OILgGLcEF@LlJCBzI@/iNs7dYA@qXsdTtZqKlPvrDedFmpM0MOvR0ZDso6xbHaSCN@5UsIDPNLiw@CKwYKlGyhNyXDE2TXwsKNv0B "Julia 1.0 – Try It Online")
-10 MarcMush
[Answer]
# [Ruby](https://www.ruby-lang.org/), ~~33~~ 32 bytes
-1 byte thanks to [Arnauld](https://codegolf.stackexchange.com/users/58563/arnauld)
```
->a{(a.sum{_1.ord+7}%26+97).chr}
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m72kqDSpcsEiN9ulpSVpuhY3FXTtEqs1EvWKS3Or4w318otStM1rVY3MtC3NNfWSM4pqIer2F5SWFCu4RauWR2copCrkAGG-QjkQFwFZKbGxEFULFkBoAA)
[Answer]
# [simply](https://github.com/ismael-miguel/simply), 76 bytes
It is a pretty long one...
Creates an anonymous function that outputs the expected result.
```
fn($S){$X=0each$S as$C;$X=&add($X&sub(&ord($C)97))out!ABCL[$_=&mod($X,26)];}
```
Yes, that's right, I'm assigning the result of `&mod` into a variable.  
Without it, it gives a syntax error, because ... I made mistakes in the compiler...
# Using the code
Simply call the function.
```
$fn = fn($S){$X=0each$S as$C;$X=&add($X&sub(&ord($C)97))out!ABCL[$_=&mod($X,26)];}
// should output "h"
call $fn("codegolf");
```
# Ungolfed
Somewhat code-y looking:
```
$fn = fn($string) => {
    $sum = 0;
    each $string as $char {
        $sum = &add($sum, &sub(&ord($char), 97));
    }
    
    $index = call &mod($sum, 26);
    
    echo !ABCL[$index];
}
```
Plain English-ish/Pseudo-code looking:
```
Set $fn to an anonymous function($string).
Begin.
    Set $sum to 0.
    
    Loop through $string as $char.
    Begin.
        Set $sum to the result of calling the function &add(
            $sum,
            Call the function &sub(
                Call the function &ord($char),
                97
            )
        ).
    End.
    
    Set $index to the result of calling the function &mod($sum, 26).
    
    Show the value !ABCL[$index].
End.
```
Both versions do exactly the same.
[Answer]
# [Japt](https://github.com/ETHproductions/japt), 8 [bytes](https://en.wikipedia.org/wiki/ISO/IEC_8859-1)
```
;x!aC gC
```
[Try it](https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&code=O3ghYUMgZ0M&input=WwpbImgiLCJlIiwibCIsImwiLCJvIiwidyIsIm8iLCJyIiwibCIsImQiXQpbImEiLCJiIiwiYyIsImQiLCJlIiwiZiJdClsiYyIsIm8iLCJkIiwiZSIsImciLCJvIiwibCIsImYiXQpbInMiLCJ0IiwiYSIsImMiLCJrIiwiZSIsIngiLCJjIiwiaCIsImEiLCJuIiwiZyIsImUiXQpbImEiLCJhIiwiYSIsImEiLCJhIl0KXS1tUg)
Input as an array of characters.
Explanation:
```
;x!aC gC
;        # C = "abcdefghijklmnopqrstuvwxyz"
 x       # Compute the following for each character, then sum the results:
  !aC    #  Find its index in C
      gC # Get the character at that index in C (wrapping)
```
You can also rearrange things [like this](https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&code=O0NnVXghYUM&input=WwpbImgiLCJlIiwibCIsImwiLCJvIiwidyIsIm8iLCJyIiwibCIsImQiXQpbImEiLCJiIiwiYyIsImQiLCJlIiwiZiJdClsiYyIsIm8iLCJkIiwiZSIsImciLCJvIiwibCIsImYiXQpbInMiLCJ0IiwiYSIsImMiLCJrIiwiZSIsIngiLCJjIiwiaCIsImEiLCJuIiwiZyIsImUiXQpbImEiLCJhIiwiYSIsImEiLCJhIl0KXS1tUg) for a different 8 byte solution which works almost exactly the same way.
[Answer]
# [Brachylog](https://github.com/JCumin/Brachylog), 14 bytes
```
ạ+₇ᵐ+%₂₆+₉₇g~ạ
```
[Try it online!](https://tio.run/##SypKTM6ozMlPN/r//@GuhdqPmtofbp2grfqoqelRUxuQ2wkUSa8DSv3/r5QEU6z0PwoA "Brachylog – Try It Online")
### Explanation
```
ạ                 String to char codes
 +₇ᵐ              Add 7 to each code (a <-> 97 becomes 104 = 0 (mod 26))
    +             Sum
     %₂₆          Mod 26
        +₉₇       Add 97
           g      Wrap into a list
            ~ạ    Char code to string
```
[Answer]
# [Vyxal](https://github.com/Vyxal/Vyxal), 9 bytes
```
øA‹∑₄%›øA
```
[Try it Online!](https://vyxal.pythonanywhere.com/#WyIiLCIiLCLDuEHigLniiJHigoQl4oC6w7hBIiwiIiwic3RhY2tleGNoYW5nZSJd)
```
øA‹∑₄%›øA
øA          Letter to number (1-indexed)
  ‹         Decrement each value in list
   ∑        Sum it up
    ₄%›     Modulo by 26 and increment
       øA   Number to letter
```
[Answer]
# [Pushy](https://github.com/FTcode/Pushy), 7 bytes
```
L7*SvOq
```
[Try it online!](https://tio.run/##Kygtzqj8/9/HXCu4zL/w////SsUlicnZqRXJGYl56alKAA "Pushy – Try It Online")
```
         The input is implicitly converted into bytecodes on the stack.
L7*      Push the length of the input, times 7.
   S     Push the sum of the stack.
    vO   Send this to the 'output stack'.
      q  Index into the ASCII lowercase alphabet (mod 26) and print the result.
```
Pushing 7 times the length comes from the fact that `a` has bytecode 97, and \$ -97 \equiv 7 \ (\text{mod} \, 3) \$. So it's equivalent to subtracting 97 from each bytecode.
[Answer]
# [Java (OpenJDK 8)](http://openjdk.java.net/), 132 bytes
```
interface T{static void main(String[]a){int i=a[0].length(),s=0;for(;i-->0;s+=a[0].charAt(i)+7);System.out.print((char)(97+s%26));}}
```
[Try it online!](https://tio.run/##JczRCoIwFIDhV9lNcIYp0kUSo6BnsDvx4qBTj81NtpMR4rMvo@vv5x9xwdTN2o7tM0ayrH2HjRaPNTAyNWJx1IoJyULJnmxf1SjXvRN0xSqvM6NtzwPIY7jmqnMeFKXpLVch@XszoL8zkEwKqcpPYD1l7sXZvM8Y4McSLkUSDqezlGrbYoyDNsa9nTftFw "Java (OpenJDK 8) – Try It Online")
[Answer]
## C# (.Net 6), 64 bytes
```
int i=0,j=0;for(;i<a.Length;)j+=a[i++]-97;return(char)(97+j%26);
```
[Try it here](https://dotnetfiddle.net/KaXcug)
[Answer]
# [J](https://www.jsoftware.com), 19 bytes
```
(26|+/)&.(_97+3&u:)
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m70wa8FOJT31NAVbKwV1BR0FAwUrINbVU3AO8nFbWlqSpmuxWcPIrEZbX1NNTyPe0lzbWK3UShMic9NVkys1OSNfyUAhTc1OQT0jNScnvzy_KCdF3Vo9MSk5JTUNyEjOT0lNz88BMYtLEpOzUyuSMxLz0lNBakBAHWLYggUQGgA)
```
(26|+/)&.(_97+3&u:)
       &.            NB. F&.G y applies G⁻¹(F(G x)) to y, rank is decided by G
         (_97+3&u:)  NB. fork converting str to char codes and subtracting 97 from each
(26|+/)              NB. fork that sums the arg and mods the result by 26
                     NB. +/ can be used because u: operates on y as a whole
                     NB. The inverse of G in this case would be to add 97 to
                     NB. the result of F and then convert char code to str
```
[Answer]
# [Bits](https://github.com/nayakrujul/bits), 130 bits = 16.25 bytes
```
1110000111000001110001011111110111010100000001100111110101011100011000000110001011001101101110000000110100111001111101010111111100
```
This was very painful.
### Explanation
```
11100001   // Get a string input
1100000    // Push 0 to the stack [this will be our running sum]
11100010   // For each character in the input string:
111111101  //   Get ord(c)
1101010    //   Add [to the running sum]
000000     //   Separator so the numbers don't get joined together
1100111    //   Push 7
1101010    //   Add [to the running sum]
11100011   // ENDFOR
000000     // Separator so the numbers don't get joined together
1100010    // Push 2
1100110    // Push 6 [this gets joined into 26]
1101110    // Mod our running sum by 26
000000     // Separator so the numbers don't get joined together
1101001    // Push 9
1100111    // Push 7 [this gets joined into 97]
1101010    // Add [to the result of the mod]
111111100  // Get chr(x)
           // [implicit output of the item on the top of the stack]
```
### Output
[![output](https://i.stack.imgur.com/QELKh.png)](https://i.stack.imgur.com/QELKh.png)
[Answer]
# [R](https://www.r-project.org/), ~~44~~ ~~43~~ 42 bytes
```
letters[sum(utf8ToInt(scan(,""))+7)%%26+1]
```
[Try it online!](https://tio.run/##K/r/Pye1pCS1qDi6uDRXo7QkzSIk3zOvRKM4OTFPQ0dJSVNT21xTVdXITNsw9n9Gak5Ofnl@UU7KfwA "R – Try It Online")
(or [38 bytes](https://ato.pxeger.com/run?1=m72waMHK5IzU5Ozi0lzbpaUlaboWN9ViNCo0c1JLSlKLiqOB4hpAYYuQfM-8EqC4trmmqqqRmbZhLET1NphuDaWM1Jyc_PL8opwUJU2I5IIFEBoA) as a function in [R](https://www.r-project.org/) ≥ 4.1).
[Answer]
# [Thon (Symbols)](https://github.com/nayakrujul/thon-symbols) `s` flag, 10 [bytes](https://github.com/nayakrujul/thon-symbols/blob/main/Codepage.md)
```
$åị$Σ26%å`
```
### Explanation
```
$åị$Σ26%å`   // (implicit input as a string)
$  $         // For each character in the input string:
 åị          //   Get the index in the alphabet
             // (implicitly create a list of all of these indexes)
    Σ        // Sum the list
     26%     // Mod by 26
        å`   // Get that letter of the alphabet
             // (implicit output)
```
[Answer]
# [Python](https://docs.python.org/3/), 74 bytes
```
from string import*
f=lambda s,l=ascii_lowercase:l[sum(map(l.index,s))%26]
```
[Try it online!](https://tio.run/##DczBCsIwDADQu1/Ri6yV4UHBg7AvEZG4ti6QNCWpuH193f3x6tYWKdfeswo7a4rl45CraDsd8kTA7wjORprAZsQXyS/pDJbu9LAve4bq6YwlpnW0EI6X27PXPWk@@2FJtHtRikMI/Q8 "Python 3 – Try It Online")
# [Python](https://docs.python.org/3/) + [`golfing-shortcuts`](https://github.com/nayakrujul/golfing-shortcuts), 47 bytes
```
lambda S:Sl[s(m(Sl.index,S))%26]
from s import*
```
(Is this one a competitive answer?)
]