[Question]
  [
According to [RollingStone](http://www.rollingstone.com/music/lists/100-greatest-singers-of-all-time-19691231), below are the 26 greatest singers of all time:
```
Aretha Franklin         Al Green
Ray Charles             Robert Plant
Elvis Presley           Mick Jagger
Sam Cooke               Tina Turner
John Lennon             Freddie Mercury
Marvin Gaye             Bob Marley
Bob Dylan               Smokey Robinson
Otis Redding            Johnny Cash
Stevie Wonder           Etta James
James Brown             David Bowie
Paul McCartney          Van Morrison
Little Richard          Michael Jackson
Roy Orbison             Jackie Wilson
```
You can get this as a list of strings [here](https://pastebin.com/k7J3S0tt).
## Task
Given a singer name, print or return a letter from `A` to `Z` which uniquely identifies this singer. (If your code returns *A* for *Bob Dylan*, then it cannot return *A* for any other singer.)
As opposed to other similar challenges, ***the mapping is up to you*** as long as it's collision-free.
## Rules
* The input is guaranteed to be one of the 26 singer names listed above with this exact spelling and without any leading or trailing whitespace.
* You may output the letter in either lowercase or uppercase. But it must be consistent.
* You are encouraged to provide a test suite for all 26 possible inputs.
* This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so the shortest answer in bytes wins!
  
[Answer]
# [Python 2](https://docs.python.org/2/), ~~80~~ 71 bytes
```
def f(s):i=sum(map(ord,s))%98%40;return chr(i-i/26*18+i/32*3-i/37*8+65)
```
[Try it online!](https://tio.run/##RZFPbxoxEMXvfIq5ROwSqrTQpjQVh0D@SFFWQRC1h6qHYT2wI8wYzRqi/fR0vIvUk@fZ4/d@Hh@aWAUZnVfTP/17pVghPCnKzrP0h/17D89KlMolNjCvUD3VSYU1aYSFR4kmH/2Ja1go1Z4a0wWXO3jB7ZbU1Ar3MA9hR1a/syC8H1Xak5dQCbySSEgRT0rOMUFBWh619UE9scAzNunuLKyhSATNRTw0lp8C9mbegEGx1K3VWzSeZbKT7SVHjB/rKrVHOlnM7yCupXiMEY12376sXWGm4SP5POCJHczCByeABR49FOUcNUoL8QsFiqDKXeorx@gJllzaoFw3hwrJm3m561qWoYE3XV8upP1Ewj7pv2dHG9hkdX7H0/q4z/Z4yIK6YZ3nVz8mV18//7QfstlBWWnGn/hmdDv4Mrnmm/FoMDY5/j6YXN9@y8@boCBgk1vd9eCgLNFsJR9Kz00dlzHLOpn/b8x7XZ8nyVw@dOd/ "Python 2 – Try It Online")
The sums of ordinals modded give numbers between `0` and `38`
The numbers larger than 25 are then shifted to fill in the blanks as below (sorted sequence shown):
```
  0  1  2  3  4  5  6  7  8  -  -  -  - 13 14  - 16  - 18  -  -  - 22 23 24 25  - 27 28 29 30  - 32  - 34 35 36  - 38
```
Subtract `18` if `i>25`:
```
  0  1  2  3  4  5  6  7  8  -  -  -  - 13 14  - 16  - 18  -  -  - 22 23 24 25
                          - 27 28 29 30  - 32  - 34 35 36  - 38
```
Add `3` if `i>31`:
```
  0  1  2  3  4  5  6  7  8  -  -  -  - 13 14  - 16  - 18  -  -  - 22 23 24 25
                          - 27 28 29 30  
                                                  - 32  - 34 35 36  - 38
```
Subtract `8` if `i>37`:
```
  0  1  2  3  4  5  6  7  8  -  -  -  - 13 14  - 16  - 18  -  -  - 22 23 24 25
                          - 27 28 29 30  
                                                  - 32  - 34 35 36  
                                            - 38
```
Which gives the sequence `0..25`
```
  0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25
```
These are then converted to `A-Z` with `chr(i+65)`
[Answer]
# [6502 machine code](https://en.wikibooks.org/wiki/6502_Assembly) routine (C64), 83 bytes
```
20 FD AE 20 9E AD 85 FC 20 A3 B6 A9 79 85 FB A0 00 84 FD B1 22 10 03 69 A0 18
45 FD 65 FB 85 FD E6 FB C8 C4 FC D0 EC E9 29 B0 FC 69 29 C9 1A 90 1C 29 0F C9
0D 90 04 69 09 90 12 C9 02 F0 0F C9 08 D0 04 A9 06 D0 06 C9 0C D0 02 A9 11 18
69 41 4C D2 FF
```
This is position-independent code, just put it somewhere in RAM and jump there, e.g. using the `sys` command.
**[Online demo](https://vice.janicek.co/c64/#%7B%22controlPort2%22:%22joystick%22,%22primaryControlPort%22:2,%22keys%22:%7B%22SPACE%22:%22%22,%22RETURN%22:%22%22,%22F1%22:%22%22,%22F3%22:%22%22,%22F5%22:%22%22,%22F7%22:%22%22%7D,%22files%22:%7B%22singer.prg%22:%22data:;base64,AMAg/a4gnq2F/CCjtql5hfugAIT9sSIQA2mgGEX9ZfuF/eb7yMT80OzpKbD8aSnJGpAcKQ/JDZAEaQmQEskC8A/JCNAEqQbQBskM0AKpERhpQUzS/w==%22%7D,%22vice%22:%7B%22-autostart%22:%22singer.prg%22%7D%7D)** (loads to `$C000`/`49152`).
**Usage:** `sys49152,"[name]"`, e.g. `sys49152,"Aretha Franklin"`.
**Important:** If the program was load from disk (like in the online demo), issue a `new` command first! This is necessary because loading a machine program trashes some C64 BASIC pointers.
**Note:** The C64 is by default in a mode without lowercase letters -- in order to be able to enter *readable* names, switch to lowercase mode first by pressing `SHIFT`+`CBM`.
---
### Explanation
The challenge is in fact to find a minimal perfect hash function for these names; for the C64, I had to find one that's easily computable in simple 8bit operations. Here's a commented disassembly listing:
```
.C:c000  20 FD AE    JSR $AEFD          ; consume comma
.C:c003  20 9E AD    JSR $AD9E          ; evaluate expression
.C:c006  85 FC       STA $FC            ; save string length
.C:c008  20 A3 B6    JSR $B6A3          ; free string
.C:c00b  A9 79       LDA #$79           ; value for adding during hashing
.C:c00d  85 FB       STA $FB
.C:c00f  A0 00       LDY #$00           ; offset for reading string
.C:c011  84 FD       STY $FD            ; and initial hash value
.C:c013   .hashloop:
.C:c013  B1 22       LDA ($22),Y        ; read next character from string
.C:c015  10 03       BPL .xor           ; if bit 8 set (shifted)
.C:c017  69 A0       ADC #$A0           ; translate to same unshifted character
.C:c019  18          CLC
.C:c01a   .xor:
.C:c01a  45 FD       EOR $FD            ; xor with previous hash
.C:c01c  65 FB       ADC $FB            ; add offset
.C:c01e  85 FD       STA $FD            ; store new hash
.C:c020  E6 FB       INC $FB            ; increment offset
.C:c022  C8          INY
.C:c023  C4 FC       CPY $FC
.C:c025  D0 EC       BNE .hashloop      ; repeat until last character
.C:c027   .modloop:
.C:c027  E9 29       SBC #$29           ; subtract $29 until
.C:c029  B0 FC       BCS .modloop       ; underflow, then
.C:c02b  69 29       ADC #$29           ; add once again ( => mod $29)
.C:c02d  C9 1A       CMP #$1A           ; value in hash range?
.C:c02f  90 1C       BCC .tochar        ; -> output
.C:c031  29 0F       AND #$0F           ; mask lowest 4 bits only
.C:c033  C9 0D       CMP #$0D           ; greater 12 ?
.C:c035  90 04       BCC .fixedvals     
.C:c037  69 09       ADC #$09           ; then just add 10 (9 plus carry)
.C:c039  90 12       BCC .tochar        ; and done -> output
.C:c03b   .fixedvals:
.C:c03b  C9 02       CMP #$02           ; 2 becomes 3 by adding
.C:c03d  F0 0F       BEQ .tochar2       ; with carry (jump after the CLC)
.C:c03f  C9 08       CMP #$08           ; if value was 8
.C:c041  D0 04       BNE .check2
.C:c043  A9 06       LDA #$06           ; new value is 6
.C:c045  D0 06       BNE .tochar        ; and output
.C:c046   .check2:
.C:c047  C9 0C       CMP #$0C           ; else if value was 12
.C:c049  D0 02       BNE .tochar
.C:c04b  A9 11       LDA #$11           ; new value is 17
.C:c04d   .tochar:
.C:c04d  18          CLC
.C:c04d   .tochar2:
.C:c04e  69 41       ADC #$41           ; add character code for 'a'
.C:c050  4C D2 FF    JMP $FFD2          ; jump to kernal CHROUT routine
```
---
### Test suite (C64 BASIC, containing the machine code routine in `data` lines)
```
0fOa=49152to49234:rEb:pOa,b:nE:pO53272,23
1sY49152,"Aretha Franklin":?":Aretha Franklin"
2sY49152,"Ray Charles":?":Ray Charles"
3sY49152,"Elvis Presley":?":Elvis Presley"
4sY49152,"Sam Cooke":?":Sam Cooke"
5sY49152,"John Lennon":?":John Lennon"
6sY49152,"Marvin Gaye":?":Marvin Gaye"
7sY49152,"Bob Dylan":?":Bob Dylan"
8sY49152,"Otis Redding":?":Otis Redding"
9sY49152,"Stevie Wonder":?":Stevie Wonder"
10sY49152,"James Brown":?":James Brown"
11sY49152,"Paul McCartney":?":Paul McCartney"
12sY49152,"Little Richard":?":Little Richard"
13sY49152,"Roy Orbison":?":Roy Orbison"
14sY49152,"Al Green":?":Al Green"
15sY49152,"Robert Plant":?":Robert Plant"
16sY49152,"Mick Jagger":?":Mick Jagger"
17sY49152,"Tina Turner":?":Tina Turner"
18sY49152,"Freddie Mercury":?":Freddie Mercury"
19sY49152,"Bob Marley":?":Bob Marley"
20sY49152,"Smokey Robinson":?":Smokey Robinson"
21sY49152,"Johnny Cash":?":Johnny Cash"
22sY49152,"Etta James":?":Etta James"
23sY49152,"David Bowie":?":David Bowie"
24sY49152,"Van Morrison":?":Van Morrison"
25sY49152,"Michael Jackson":?":Michael Jackson"
26sY49152,"Jackie Wilson":?":Jackie Wilson"
27dA32,253,174,32,158,173,133,252,32,163,182,169,121,133,251,160,0,132,253,177
28dA34,16,3,105,160,24,69,253,101,251,133,253,230,251,200,196,252,208,236,233
29dA41,176,252,105,41,201,26,144,28,41,15,201,13,144,4,105,9,144,18,201,2,240
30dA15,201,8,208,4,169,6,208,6,201,12,208,2,169,17,24,105,65,76,210,255
```
**[Online demo of test suite](https://vice.janicek.co/c64/#%7B%22controlPort2%22:%22joystick%22,%22primaryControlPort%22:2,%22keys%22:%7B%22SPACE%22:%22%22,%22RETURN%22:%22%22,%22F1%22:%22%22,%22F3%22:%22%22,%22F5%22:%22%22,%22F7%22:%22%22%7D,%22files%22:%7B%22testsuite.prg%22:%22data:;base64,AQgoCAAAgUGyNDkxNTKkNDkyMzQ6h0I6l0EsQjqCOpc1MzI3MiwyMwBZCAEAnjQ5MTUyLCLBUkVUSEEgxlJBTktMSU4iOpkiOsFSRVRIQSDGUkFOS0xJTiIAgggCAJ40OTE1Miwi0kFZIMNIQVJMRVMiOpkiOtJBWSDDSEFSTEVTIgCvCAMAnjQ5MTUyLCLFTFZJUyDQUkVTTEVZIjqZIjrFTFZJUyDQUkVTTEVZIgDUCAQAnjQ5MTUyLCLTQU0gw09PS0UiOpkiOtNBTSDDT09LRSIA/QgFAJ40OTE1Miwiyk9ITiDMRU5OT04iOpkiOspPSE4gzEVOTk9OIgAmCQYAnjQ5MTUyLCLNQVJWSU4gx0FZRSI6mSI6zUFSVklOIMdBWUUiAEsJBwCeNDkxNTIsIsJPQiDEWUxBTiI6mSI6wk9CIMRZTEFOIgB2CQgAnjQ5MTUyLCLPVElTINJFRERJTkciOpkiOs9USVMg0kVERElORyIAowkJAJ40OTE1Miwi01RFVklFINdPTkRFUiI6mSI601RFVklFINdPTkRFUiIAzAkKAJ40OTE1MiwiykFNRVMgwlJPV04iOpkiOspBTUVTIMJST1dOIgD7CQsAnjQ5MTUyLCLQQVVMIM1Dw0FSVE5FWSI6mSI60EFVTCDNQ8NBUlRORVkiACoKDACeNDkxNTIsIsxJVFRMRSDSSUNIQVJEIjqZIjrMSVRUTEUg0klDSEFSRCIAUwoNAJ40OTE1Miwi0k9ZIM9SQklTT04iOpkiOtJPWSDPUkJJU09OIgB2Cg4AnjQ5MTUyLCLBTCDHUkVFTiI6mSI6wUwgx1JFRU4iAKEKDwCeNDkxNTIsItJPQkVSVCDQTEFOVCI6mSI60k9CRVJUINBMQU5UIgDKChAAnjQ5MTUyLCLNSUNLIMpBR0dFUiI6mSI6zUlDSyDKQUdHRVIiAPMKEQCeNDkxNTIsItRJTkEg1FVSTkVSIjqZIjrUSU5BINRVUk5FUiIAJAsSAJ40OTE1MiwixlJFRERJRSDNRVJDVVJZIjqZIjrGUkVERElFIM1FUkNVUlkiAEsLEwCeNDkxNTIsIsJPQiDNQVJMRVkiOpkiOsJPQiDNQVJMRVkiAHwLFACeNDkxNTIsItNNT0tFWSDST0JJTlNPTiI6mSI6001PS0VZINJPQklOU09OIgClCxUAnjQ5MTUyLCLKT0hOTlkgw0FTSCI6mSI6yk9ITk5ZIMNBU0giAMwLFgCeNDkxNTIsIsVUVEEgykFNRVMiOpkiOsVUVEEgykFNRVMiAPULFwCeNDkxNTIsIsRBVklEIMJPV0lFIjqZIjrEQVZJRCDCT1dJRSIAIAwYAJ40OTE1Miwi1kFOIM1PUlJJU09OIjqZIjrWQU4gzU9SUklTT04iAFEMGQCeNDkxNTIsIs1JQ0hBRUwgykFDS1NPTiI6mSI6zUlDSEFFTCDKQUNLU09OIgB+DBoAnjQ5MTUyLCLKQUNLSUUg10lMU09OIjqZIjrKQUNLSUUg10lMU09OIgDODBsAgzMyLDI1MywxNzQsMzIsMTU4LDE3MywxMzMsMjUyLDMyLDE2MywxODIsMTY5LDEyMSwxMzMsMjUxLDE2MCwwLDEzMiwyNTMsMTc3AB0NHACDMzQsMTYsMywxMDUsMTYwLDI0LDY5LDI1MywxMDEsMjUxLDEzMywyNTMsMjMwLDI1MSwyMDAsMTk2LDI1MiwyMDgsMjM2LDIzMwBsDR0AgzQxLDE3NiwyNTIsMTA1LDQxLDIwMSwyNiwxNDQsMjgsNDEsMTUsMjAxLDEzLDE0NCw0LDEwNSw5LDE0NCwxOCwyMDEsMiwyNDAAtQ0eAIMxNSwyMDEsOCwyMDgsNCwxNjksNiwyMDgsNiwyMDEsMTIsMjA4LDIsMTY5LDE3LDI0LDEwNSw2NSw3NiwyMTAsMjU1AAAA%22%7D,%22vice%22:%7B%22-autostart%22:%22testsuite.prg%22%7D%7D)**.
[Answer]
# [Python 2](https://docs.python.org/2/), 68 bytes
```
def f(n):i=hash(n)%337%125%45;return chr(65+i-i/25*2-i/29*21+i/35*2)
```
[Try it online!](https://tio.run/##NVJNT8MwDL33V/gyteNTdAwEiAMbHxKiYhoIDoiD13qrWeZMbjbUXz@SlOXQ5Dmx/d5z162rreS7XUVzmGfSv@bbGpvan3qDwWXvLB/2zoc3Sm6jAmWt2cXwkI/5NB8e5GG7OsjPDvl04GF/J7iiBm7hK73zGTXCo6IsDUt6BOkUWxjXqIaaAB/MlhuYKDWG2hB4wxWMrV1SAM@2FnghERtzC9QtCzxhG29Hdgb3rcF49@p8nSlVFcsi1nG0ZYJPKxVprBVZjdT@xvcT3BgoyjGqk67zCztnCKZcenpV5GpbeNUZN137OwNPStTJsDNSBxPf3UVqXC7hGReLrtk7C8K7N6uDjxqIERSk5UbbPfki2NCpXnnFLfiqLP/dgnbxXvkxRKOcQ4gaArrHLVcwsr8cnfhAgcKq7pkWQQMZ/75c7sv5Y/CDTQh8J8ncKoRJgXc0Tuw6AVgriwt/gA/0kyTC7pumJz@WJWusOqqyhly2wnU2P4q5fb92fw "Python 2 – Try It Online")
[Answer]
# Javascript, ~~138~~ 132 characters
As all initials are unique, except for `MJ` = **M**ichael **J**ackson / **M**ick **J**agger, I check for Michael Jackson specifically (the only one with an `h` on the 4th position), and for all other names I created a string with the initials followed by a unique letter.
```
s=>s[3]=='h'?'y':"AFaRCbEPcSCdJLeMGfBDgORhSWiJBjPMCkLRlROmAGnRPoMJpTTqFMrBMsSRtJCuEJvDBwVMxJWz".split(s.replace(/[^A-Z]/g,''))[1][0]
```
### Code Snippet
Try it here:
```
var solution =
s=>s[3]=='h'?'y':"AFaRCbEPcSCdJLeMGfBDgORhSWiJBjPMCkLRlROmAGnRPoMJpTTqFMrBMsSRtJCuEJvDBwVMxJWz".split(s.replace(/[^A-Z]/g,''))[1][0]
var testnames = [
"Aretha Franklin",
"Ray Charles",
"Elvis Presley",
"Sam Cooke",
"John Lennon",
"Marvin Gaye",
"Bob Dylan",
"Otis Redding",
"Stevie Wonder",
"James Brown",
"Paul McCartney",
"Little Richard",
"Roy Orbison",
"Al Green",
"Robert Plant",
"Mick Jagger",
"Tina Turner",
"Freddie Mercury",
"Bob Marley",
"Smokey Robinson",
"Johnny Cash",
"Etta James",
"David Bowie",
"Van Morrison",
"Michael Jackson",
"Jackie Wilson"
];
testnames.forEach(name=>document.body.append( solution(name) ));
```
[Answer]
# [Java (OpenJDK 8)](http://openjdk.java.net/), 128 126 115 113 bytes
Not too shabby for a java submission!
Thanks to Kevin for saving me a whole lot of bytes with the lambda expressions!
```
s->{int a=0;for(int i:s.substring(1,6).getBytes())a+=i;a*=a==431?0.108:2.65108;return(char)(a==1341?70:a%26+65);}
```
[Try it online!](https://tio.run/##ZVJdT9tAEHx2fsU2UiW7gJXwkVaxXERoQUIEUEDtA/CwcRbnyHkvujsHWVF@e3p3DqhqHyzfrnZ3ZnfmFVd4oJbEr7PFtpBoDIxR8LoTCbakX7AguFl3IIqKOWoo43urBZdgkqwTbTqdyFi0ooA2/fgMgpe1hRzW3QtNs5kgGJMuat1096E7UVPSFu4ksvXxD1yJGYzUmyAfXqk5wzUxK/bhvaWV6/@teEbaJ8bCkSAJV1gsTFtzpsnOES408kKKkLrCigyMtHoL4UhN3UpaUmDw01qEUBEQsIJzpRYB/UzCpSYKTa5hJRgusaEd8MJ1lWXL4xcyjJXWYkdiohq41dP38EEwwkOtua2@FtZKgoknr2fve3ID52jmgZNcCQN3msyO5B3WEsbFOWrLbcYv8aNxZ/PBrXXlE39cLtuFi4W/k5DvfNANn/ud2y0rt2ED7viCfcUmc7ot66l0uu3kWymnQ@WEjz@ExMSZIPJmgMrpyfQWnBF74SPxEmMqiUs7/5T3ErhvjKUqVbVNl67fxvjYe4Y96D7ZJ9t1jyrltAzZJAwgaQg8QPSi9IepYNj6J0BH0b9TJcfm/6GmnejcGL6/THkD7JhvzcH3tesGzHuZR/NvMTSpqacmAMf9/UGSlmRHjSUTJwnu5SLDLznm@fFR/7SX9nvfhofp4MT9M@c4p23s1UxiV9E/Ou6ffu0N8fPhYG9wkmSbbZR1Nts/ "Java (OpenJDK 8) – Try It Online")
[Answer]
# Python 3, ~~132~~ ~~99~~ 96 bytes
```
lambda m:chr(98+"ԇ̲ЙГ̫ѼӿИԸՋжʾҍϴЬֺΝעЕΞϾҞ֜ӣ֪".find(chr(sum(map(ord,m)))))
```
[Try it online!](https://tio.run/##LZA9SwNBEIZ7f8VgkwsGGxsVLEz8APEwJKKFWkzuNrkle7NhbhO5X2AhViIoqIV2aiUiIqK9iJ5f8efE3Uu22Xl3d973me2kJtI0NWjCHGwPFMaNECGeDSL2ZqYnxn/23m6zk@zw7frz6fslO/55@N3P7l@fvw4@7rKb/uP72d9FdvR@/vH8dd4//b7sX41PNiWFnjNIurEXY8fTHJbioluD@txWYZ6FiRCWGKmtJBVKhXkFyyyEK2uYQiVCViJxSjcEG6gqJGPlourJBKosEiVSq30ZtGEFWy3BVtUxhorWbWHrdUkI612m/GZFRwSrgki7iCUWYSgF@IKDLuc@yD1JsIyp6y3rBviOIB2JhdTmu4DYmqdgoSQludWasTw1Z0etUQ5Zfkwi99yIno3Z1BTmFIvGoKWN88nyHcqsd53PAvZkCGW9Kx1AFbsK/KCCbCiH2EACXzPLYeqqNEYJqMnAflQ4/IcIhbLmQXv4pKZTWOPGqMGdOxKpnN4Za2oGAjtxfXYMOizJeE2PiiUqDv4B "Python 3 – Try It Online")
Not golfed brilliantly, but I thought I'd give this a go.
-33 bytes thanks to modifications made by TFeld.  
-3 bytes by using `find` instead of `index` thanks to ovs.
[Answer]
# Perl, ~~56~~, ~~54~~, ~~50~~, 46 +1 (-p) bytes
~~$*=crypt$*,DT;/..(.)/;$\_=$1;y/01268ADIJNVW/adhilmnpqsux/~~
~~$*=crypt$*,DT;/..(.)/;$*=$1;y/01268JVW/hlmpqsux/;$*=lc~~
~~$*=crypt$*,mO;/..(.)/;$*=$1;y/035eft/AHPRXZ/;$*=lc~~
Thanks to Dom's comment could save 4 more bytes, also changed to uppercase to fit better requierements.
```
$_=crypt$_,mO;y/035eft/AHPRXZ/;/..(.)/;$_=uc$1
```
[Try It Online](https://tio.run/##HY9Nb8IwDIbv@RU@cNikjW6aOKEd@J4QFVVB27QLMq1HI4JTuQGUP7/O7SmJFb/v89QkbtS2g8N7IbEOg8PTZTtOhsOH4WMy1ungdRyTl7cR/YZk8pHl3z/92BVtOxEKFcJSkM/OsskxwqxCcdSYhbvZBjKhxlE0O7zAzPszmbWvGDbE7NmkKDfLsMJIZuqPMI8O2WyDLuZUlpZPZhfoZgm@PJckZo0XamAq/s4mw6uDtJihBNaGjQ3BEeS2UIDS5D7CVo620ZqJg5UQKZ8/kgTItCWY1BZnWOPppLl7ywj7q7Del9JVE6QkxVViD5Z2TmpxUYMIGmO5C@5cWJWxqcwiBISez8zxZkuY@rsl84kMqRfpQdIOjpx@K879vp6dnHX6@vN1sJ6b9rn@Bw)
[Answer]
# PHP, ~~90 88 86~~ 72+1 bytes
might become even shorter with a different modulo.
```
<?=strtr(chr(hexdec(substr(md5($argn),0,2))%65+58),"^<adins",bcfgqvx)&_;
```
Save to file and run as pipe with `-nF` or [try it online](http://sandbox.onlinephpfunctions.com/code/4de4010306a23f4ee8796f4ab2dd52cf98632c11).
[Answer]
# [MATL](https://github.com/lmendo/MATL), 28 bytes
```
s98\40\2Y2'ijkl o qst uz'hw)
```
[Try it online!](https://tio.run/##PVDNbtswDL73KbgBg9dbEQzFtluTtgHaGAmyYkOB9sDYbMxZFl1KtuG9fCZZbi6CKOr7bdCb0@L652eGL7ARaUF6UlhcA9u28w6@FlISwIGMDDCI1g7eRMGxPRpKn4Cb1nDB3oyXJ/fj@8u3q5fF8yLjv7W5k/W784/dv6waLk/966cgk2PbBngAg2gZ1OQtEV34zob9tvOR1VcYD3IEqFGqJCqjs5KdZ1t4KCpULDypO2U3SgEA94q2NmyzC4BsjyOswh9DbprvTM8OdkrO0Di9/MIGViI1TdODVBY2ZK0kfI7aB5NrHNN@KQe4HQ2m7dYHsj2VZciSyDz1TPBHglNNhNiQg6XKkCA77AzkxQrV29nBhr0PRe45himTbRlhqwd2s40bA2slmjPJgdTDLrjwySQXNTzg8ThrPrFFeOrUzvO9RosEOWnR6XgOksde5haa0MAIgZrth2jswob60FWpO@8RpjzTeIs9l7CUgVM1v9FCLqpn03kMRCZAivrMGe6xIDbx5T8 "MATL – Try It Online")
### Explanation
```
s98\40\
```
Implicitly get the input string. Sum the characters of the input string, and do it modulus 98 followed by modulus 40. Results in one of the following numbers: `38 18 13 34 29 23 27 30 5 28 22 1 0 16 7 32 8 14 3 36 25 4 2 6 24 35` (in order of the Pastebin list).
```
2Y2'ijkl o qst uz'h
```
Push the (lowercase) alphabet with `2Y2`. This takes care of the numbers in the range [1,26]. However, some numbers are missing, and we have numbers up to 38. Hence, we append (`h`) a string that takes care of the higher numbers, by mapping these numbers to the 'missing' letters. The spaces can be anything, I used capital letters in my original program for my own convenience.
```
w)
```
We can now index the number from the first step into the string from the second step with `)`. We use `w` to get the arguments in the correct order. While it may seem that we use 0-based indexing (the numbers vary from 0 to 38, and the string is 39 characters long), the reality is actually a bit more complicated: we use 1-based modular indexing, a feature unique to MATL. This means that `1` indexes to `a`, `38` actually indexes to `u`, and `0` indexes to the final `z` of the string.
[Answer]
# Python 2, 50 43 bytes
Credit to [japh](https://codegolf.stackexchange.com/users/75067/japh) for the new version
```
lambda n:chr(hash(n)%2354%977%237%54%26+65)
```
[Try it online!](https://tio.run/##RZBLb8IwEITv/Iq9IBKVE32gVuLAs1LVqAiq9oA4LPFCLMy62hiq/Hq6dpB68k48nvmyP02oPA@u69GmNxYKFcJCkI/Ocq/fGzt4FaI4rrCBaYXiqI7K70gCLB1yUDl3F1vDUqh21KgubHmENzwcSFSt8QRT74@k86dlhM@zcLp58xXDOzH7WLEQMsYSFCTlWVIOysUyvGIT3078DopI0NzErNH@WHDS8AYUynKdoj6C8qxiHB9uPaz8WFfRHuiiNd@eTaKYh4BKe0p/lk6YiP@NOTO8WAMT/2sjwBLPDopyihI4QXwhQ@FFbNv6bkNwBCtb6qJMu4cKyWl4eWwtK9/Ah@xuD@L3SGJd1NvrfuTwtDMI/FJWklXKm3HeHdw/PnSfh0Mdhl0dB093T4/59Ucsh2zTuhQ7h70XiBPo0tbbvJN0Ei8dSHbYa2CfO2ZkbBmyrJX5vzHvtD5HnJm8b65/)
Note: This is dependent on the `hash` builtin and will not work in all implementations
[Answer]
# Ruby, 63 bytes
```
->s{((0x3c4001c151861b27d>>s.sum%98%66).to_s(2).sum%48+64).chr}
```
Adds the ascii codes of the input, takes them mod 98 and then mod 66 to get a one of 26 unique numbers `n` in the range 0..65. The huge hexadecimal number contains a `1` bit in each of these 26 places, so by rightshifting it by `n` we obtain a number with 1..26 `1` bits in it. We count the `1` bits by adding the ascii codes and taking mod 48, then add 64 and convert to an ASCII code.
**Test program**
the `map` iterates through the singers printing the letter code and singer. It then returns an array of the letter codes, which is `sort`ed to demonstrate that each letter is used once.
```
f=->s{((0x3c4001c151861b27d>>s.sum%98%66).to_s(2).sum%48+64).chr}
a= [
  "Aretha Franklin","Ray Charles",
  "Elvis Presley","Sam Cooke",
  "John Lennon","Marvin Gaye",
  "Bob Dylan","Otis Redding",
  "Stevie Wonder","James Brown",
  "Paul McCartney","Little Richard",
  "Roy Orbison","Al Green",
  "Robert Plant","Mick Jagger",
  "Tina Turner","Freddie Mercury",
  "Bob Marley","Smokey Robinson",
  "Johnny Cash","Etta James",
  "David Bowie","Van Morrison",
  "Michael Jackson","Jackie Wilson"
]
p a.map{|i|p [f[i],i];f[i]}.sort
```
**Output**
```
["S", "Aretha Franklin"]
["E", "Ray Charles"]
["R", "Elvis Presley"]
["J", "Sam Cooke"]
["X", "John Lennon"]
["C", "Marvin Gaye"]
["M", "Bob Dylan"]
["W", "Otis Redding"]
["V", "Stevie Wonder"]
["Y", "James Brown"]
["D", "Paul McCartney"]
["Q", "Little Richard"]
["Z", "Roy Orbison"]
["P", "Al Green"]
["O", "Robert Plant"]
["K", "Mick Jagger"]
["N", "Tina Turner"]
["L", "Freddie Mercury"]
["G", "Bob Marley"]
["I", "Smokey Robinson"]
["A", "Johnny Cash"]
["F", "Etta James"]
["H", "David Bowie"]
["U", "Van Morrison"]
["B", "Michael Jackson"]
["T", "Jackie Wilson"]
["A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z"] 
```
[Answer]
# [Octave](https://www.gnu.org/software/octave/), ~~85 83 80~~ 74 bytes
```
@(n)('A':'Z')(mod(n([1 2 8])*[1;15;47],124)=='#iZo,gp<C&4Y1!8-G`Kn3wtTIO')
```
This mess of an anonymous is the result of some messing around in MATLAB trying to find a good way to encode the data.
Basically after a quick analysis, only letters 1,2, and 8 of the input string (smallest string is 8 chars, so we are good) are needed to produce a unique value from each input. The hard part is then converting that unique value into something usable.
MATLAB is terrible at compressing data, so I had to look for another way to make the lookup mapping. I set out trying to find some function on the three input letters that resulted in a unique value that was also a printable ASCII value so that I could embed the mapping in a string of one character per input.
It turns out that matrix multiplying the characters at index `[1 2 8]` by the integer matrix `[1;15;47]` and then performing mod 124 results in unique values which all printable ASCII (and none are a `'` character which would bugger up string literals). Pleasingly the mapping ends with `TIO` which is completely accidental. Interestingly this is the **only mapping** for this equation that gives 26 unique printable ASCII characters. 
So basically that is my lookup mapping and calculation. Doing the lookup is simply a case of performing the calculation and comparing with the mapping. Adding on `'A'-1` to the index in the map results in a character A-Z.
You can [try it online](https://tio.run/##LZHha9swEMW/56@4UZjt0gacZVtpaliSrqFdTUIaOtZS2MW@JkeUUzkrDqb0b88kL/qkx0nv/Z5kC4c1HQS3VGXv0VDJrRFuFGVjWKJONMcGxmtUQ5VXP03NFcyUKkON1w@4hbG1G/L7O7sWuCcRG@7lqDULTLAJs5FdwnVjMEymzlvMqSxZVsHCUc0Ev62UpMEmoMBI7T4cnuHOQF6MUZ20iffsnCGYc@GhygBoG5jqkqs2dmhgokQtuV2SOpj5VBeAuNjAHa5WbcqCBWGxU2nVjQYcgpy02GlzBM5D67bl1jdswBuy/I8JXcU/DFbr8CrOIbTcXlxjzSWM7J5D8UcUyK3qES8P2GT84WJzdPK7UJ9N0B@DzutOsm63e/gRSxJHw@gyeoqSeGvLWOLnFHpw8ZKcPqeD9Oug//3lLO31kyyLTvjJnq3ersaf@3/STxfnk7@/5MveLW6nUXJ4tQqcpZe9bx3wq@TqLfYxcfvr7/yRJB2S8vAP "Octave – Try It Online") on TIO, which shows the full mapping of inputs and outputs. For completeness the full mapping is also below:
```
'Aretha Franklin' ==> B
'Ray Charles'     ==> S
'Elvis Presley'   ==> F
'Sam Cooke'       ==> V
'John Lennon'     ==> L
'Marvin Gaye'     ==> N
'Bob Dylan'       ==> C
'Otis Redding'    ==> Q
'Stevie Wonder'   ==> X
'James Brown'     ==> I
'Paul McCartney'  ==> R
'Little Richard'  ==> M
'Roy Orbison'     ==> T
'Al Green'        ==> A
'Robert Plant'    ==> U
'Mick Jagger'     ==> P
'Tina Turner'     ==> Y
'Freddie Mercury' ==> H
'Bob Marley'      ==> D
'Smokey Robinson' ==> W
'Johnny Cash'     ==> K
'Etta James'      ==> G
'David Bowie'     ==> E
'Van Morrison'    ==> Z
'Michael Jackson' ==> O
'Jackie Wilson'   ==> J
```
---
* Saved 2 bytes tweaking mapping to remove `+32`.
* Saved 3 bytes by making Octave-only using logical indexing of `'A':'Z'` rather than find.
* Saved 6 bytes by doing sum of multiplications using matrix multiplication.
[Answer]
# JavaScript (Chrome), 102
**Note** Unfortunately it works only in Chrome, because of implementation-dependent approximations in parseInt() (thanks @Arnauld)
```
s=>s[0]=='L'?'z':"ab.c..defghijklmn...o..pqrst.u.vwxy"[parseInt(s.replace(/ /,'o').slice(0,14),36)%35]
```
I looked for a hash function, taking a slice of each name, converting to numbers using base 36 and then applying a modulo.
I used this code to look for the best hash:
```
x=`Al Green\nAretha Franklin\nBob Dylan\nBob Marley\nDavid Bowie\nElvis Presley\nEtta James\nFreddie Mercury\nJackie Wilson\nJames Brown\nJohn Lennon\nJohnny Cash\nLittle Richard\nMarvin Gaye\nMichael Jackson\nMick Jagger\nOtis Redding\nPaul McCartney\nRay Charles\nRobert Plant\nRoy Orbison\nSam Cooke\nSmokey Robinson\nStevie Wonder\nTina Turner\nVan Morrison`.split(`\n`)
max=0
for(m=26;m<60;m++)
  for(i=0;i<20;i++)
    for(j=i;++j<20;)
      for(k=0;k<37;k++)
      {
        S=new Set();
        f=k ? (k-1).toString(36) : ''
        x.forEach(x=>(n=parseInt(x.replace(/ /,f).slice(i,j),36)%m, S.add(n)))
        if (S.size > max) console.log(i,j,f,m,max=S.size)
      }
```
And the results:
```
0 1 "" 26 14
0 2 "" 26 15
0 4 "" 26 16
0 5 "" 26 18
0 6 "0" 26 19
0 6 "3" 26 20
0 8 "a" 26 21
2 5 "7" 28 23
0 14 "h" 35 24
0 14 "o" 35 25
2 9 "" 51 26
```
The best hash function gives 26 different values between 0 and 50, but I used a different one, with 1 duplicate but a smaller range.
**Test**
```
var names=x=`Al Green\nAretha Franklin\nBob Dylan\nBob Marley\nDavid Bowie\nElvis Presley\nEtta James\nFreddie Mercury\nJackie Wilson\nJames Brown\nJohn Lennon\nJohnny Cash\nLittle Richard\nMarvin Gaye\nMichael Jackson\nMick Jagger\nOtis Redding\nPaul McCartney\nRay Charles\nRobert Plant\nRoy Orbison\nSam Cooke\nSmokey Robinson\nStevie Wonder\nTina Turner\nVan Morrison`.split(`\n`)
var F=
s=>s[0]=='L'?'z':"ab.c..defghijklmn...o..pqrst.u.vwxy"[parseInt(s.replace(/ /,'o').slice(0,14),36)%35]
var Singers={}
names.forEach(n=>Singers[F(n)]=n)
;Object.keys(Singers).sort().forEach(i=> console.log(i, Singers[i]))
```
[Answer]
# C, ~~65~~ ~~55~~ 49 bytes
~~`h(char*s){return*s<77?(*s^s[5]+40)%13+65:(s[5]&s[4]+s[1])%13+78;}`~~
~~`h(char*s){return*(long*)s%887%392%224%120%67%40%26+65;}`~~
Same approach as [KSab's answer](https://codegolf.stackexchange.com/a/145219/75067). C doesn't provide a string `hash` function like Python. Or does it?
```
h(char*s){return*(long*)s%2004%857%361%94%26+65;}
```
[Try it online!](https://tio.run/##ZZLdbtpAEIXveYoRlSvbOC1NE9rKaaWSPykKBJGovUi5WOwFj1hm092FyI14djrGGDvtXqw8n2ZnzoxPcpQoQfPtG6RErVIJZ9alqN9l31qvkMIps23mJ5kwoQ1ejHQrQ6GvNM3DwHrH3e6J9/n0k/ex98H7cuId9zq903izTTRZB7tXYJHm0tjHCXyFlxbwaX9XcG2kpHa0j7luJuDKCFooPOC@nsJFzkqbYCCMknlFLsQaU@jrZ5QVulRrtDAy0jbyLp0TcCOW0lbkysg0RQkDaZKVOSTeiGTB9Ccqq6mG/BD6Rj/XSGcEt5JIv0KUw7mwWYVu0TklYYzFKtKK8ghrJLgW@UH0oMiQCor2jcaMF8zmvMAK3Tmeblxop3nFRmKlYJCcC@OonnksWExWrOsw9FhPpXEw4p26muVwZ6bYaHsvlnCu9eIg737JQQ78HKmZ5@S6WJamtBb4gCTggW1Sox@CYKCN2ffYxC0kB0M2hMU/Us8qj8D7f8BjdxK3dsnJ8skvXbXW/MdDEUEznAY7b5X@hMwPS8uGgQjgqBlPg7i1KUsuBZIf7D1ZAIx3n7@tNs7fK4hgGP0vKoK3LCgo82fagI88TDcGhDMYxtDpYFW4OE@Gy8/8tpeAZ3/xClhRKSioauIkiKARlKU3u3s/VbdQvv0L "C (clang) – Try It Online")
`h` returns an `int` whose values are the ASCII codes for `A .. Z`.
[Answer]
# APL (Dyalog), 48 bytes
```
⎕A[' $%&().279<?@CL'⍳⎕UCS 78|7⊥⎕UCS⍞]
```
Assumes `⎕IO←0` (array indexing set to start from 0 instead of 1).
[Try it online!](https://tio.run/##ZZGxahtBEIZ7BVKYkMQukimSnASywW6UgCGRzpLA6JCQZKcIKUZ3a92i1W6YW0kcsVsVxjZ24UcwuHNhUqbRo9yLxLOngwRyze1/M/P/3@3gD7UdpajM@A8/idRjQUm2vPbqJGyM0CLUEyW1B15dQZuEcMc@puDHSEokTpmRIAs9hdqybKq5TKBHIlEiZR3IcAKHOGZnVgOcgm/MRPB5KDXCcEY6rxyaWENHaG1cRItEFEkBgaBwRrkP0lxqaGPqZhtmBIEjSAtxkHK@C5iyeQoMJXWSW3Ut8/SdnR4XOZr5MYlduxVzjvlqdJRTNK1Fpp3mf5a/oUFm4XwOcC4jaJiFdAA9nCkIQh/J6hziGDUEhkiuUzvSWiWgL0O@qGh9DzEKxebhZN3SNyl0aVQMuO@ORCqnS6UTXsPP7Oq2/s179nzjxctXrze33ryFd@8/lCs7e7VP@5@/@B0vu3zkniN/ALWPp7Xs/G6tsstf38/YY3Vf7LRU4oJbrHOG/9b7b3n1sJtd/Gaiajlb3hTzlepfryc "APL (Dyalog Unicode) – Try It Online")
### Explained
It's a complete program; the outer part `⎕A[]` is indexing somewhere into the uppercase alphabet to get the output character. Inside the brackets it reads right-to-left, and `⍞` is a prompt for a string input. `⎕UCS` turns that into Unicode char values. `78|7⊥` decodes those values as if they were digits in base 7, then takes the answer modulo 78 (brute forced to find a base and modulo combination which give usable ASCII character values). `⎕UCS` again to turn that single number into a character, and look it up `⍳` in the magic string `'...'` of 26 identifier characters. That position becomes the index into the `⎕A[]` uppercase alphabet. (There are control chars in the string, the ASCII codes are `11 14 18 20 22 23 24 25 26 30 31 32 36 37 38 40 41 46 50 55 57 60 63 64 67 76`).
The full mapping is:
```
      singers←'Aretha Franklin' 'Al Green' 'Ray Charles' 'Robert Plant' 'Elvis Presley' 'Mick Jagger' 'Sam Cooke' 'Tina Turner' 'John Lennon' 'Freddie Mercury' 'Marvin Gaye' 'Bob Marley' 'Bob Dylan' 'Smokey Robinson' 'Otis Redding' 'Johnny Cash' 'Stevie Wonder' 'Etta James' 'James Brown' 'David Bowie' 'Paul McCartney' 'Van Morrison' 'Little Richard' 'Michael Jackson' 'Roy Orbison' 'Jackie Wilson'
      f←{⎕A[' $%&().279<?@CL'⍳⎕UCS 78|7⊥⎕UCS⍵]}
  
      ¯1⌽' ',(↑singers),f¨singers
┌→────────────────┐
↓P Aretha Franklin│
│J Al Green       │
│M Ray Charles    │
│N Robert Plant   │
│U Elvis Presley  │
│Z Mick Jagger    │
│L Sam Cooke      │
│G Tina Turner    │
│F John Lennon    │
│B Freddie Mercury│
│Q Marvin Gaye    │
│H Bob Marley     │
│K Bob Dylan      │
│C Smokey Robinson│
│D Otis Redding   │
│T Johnny Cash    │
│Y Stevie Wonder  │
│I Etta James     │
│X James Brown    │
│O David Bowie    │
│E Paul McCartney │
│V Van Morrison   │
│A Little Richard │
│S Michael Jackson│
│R Roy Orbison    │
│W Jackie Wilson  │
└─────────────────┘
```
And the sorted letters of the mapping is exactly the uppercase alphabet (no dupes or missing):
```
      f¨singers
┌→─────────────────────────┐
│PJMNUZLGFBQHKCDTYIXOEVASRW│
└──────────────────────────┘
      (⊂∘⍋⌷⊢) f¨singers    ⍝ sorted
┌→─────────────────────────┐
│ABCDEFGHIJKLMNOPQRSTUVWXYZ│
└──────────────────────────┘
      ⎕A ≡ (⊂∘⍋⌷⊢) f¨singers    ⍝ matches the alphabet     
1
```
[Answer]
## Javascript, 98 bytes
```
s=l=>("heCysvCm hirDb iiesm ultOyr rb c ndeMbeonh tdvMnacic".indexOf(l[4]+l[2])/2+10).toString(36)
```
I found that the combination of the 2nd and the 4th character of the names is unique for each of them. 
Therefore I create a string with the combinations of `name[4] + name[2]`, not `name[2] + name[4]` or I would have a repetition of the char group `eh` of the first name Aretha Franklin `eh` and when Smokey Robinson and Johnny Cash `oehn` are concatenated.
I could just move Johnny Cash to another position of the string and get a different mapping, but concatenating the 4th and the 2nd character in this order avoids the collision and leaves the dataset order intact without adding more length to the solution. So I decided to go that way (it's just personal preference)
I search for the position of the concatenation of the 4nd and 2nd letter of the given parameter in the string and divide it by 2 so that I get a number between 0 and 25. Then I add 10 and convert it to string from base 36, where 10 corresponds to `a` and 35 to `z`
```
let singers = [
  "Aretha Franklin",
  "Ray Charles",
  "Elvis Presley",
  "Sam Cooke",
  "John Lennon",
  "Marvin Gaye",
  "Bob Dylan",
  "Otis Redding",
  "Stevie Wonder",
  "James Brown",
  "Paul McCartney",
  "Little Richard",
  "Roy Orbison",
  "Al Green",
  "Robert Plant",
  "Mick Jagger",
  "Tina Turner",
  "Freddie Mercury",
  "Bob Marley",
  "Smokey Robinson",
  "Johnny Cash",
  "Etta James",
  "David Bowie",
  "Van Morrison",
  "Michael Jackson",
  "Jackie Wilson"
]
s=l=>("heCysvCm hirDb iiesm ultOyr rb c ndeMbeonh tdvMnacic".indexOf(l[4]+l[2])/2+10).toString(36)
singers.forEach(singer => console.log(s(singer), singer))
```
[Answer]
# [Wolfram Language (Mathematica)](https://www.wolfram.com/wolframscript/), 101 ~~126~~ bytes
```
Alphabet[][[#&@@#&@@Position[(t=ToCharacterCode)@"nZ-Be_;f%d^q 0w@x~KDaLJ&`k",Total@t@#~Mod~98+32]]]&
```
`+32` seems leading to the shortest stirng hashtable in Mathematica `InputForm`.
[Try it online!](https://tio.run/##XVFdi9swEHzPr1h8NLRcSkr70hICzkfvII05k4QWanztxt7EwrLUrjfJmdL89VSyUw7uQaCRNLMzowqloApFZXjZjS@vZbyxswIZMyGe2ZxGeizhzWiifxW4JUnSJLnph6Ffsa2VKGsSCQPz/e2Ufox2r/LH3/DuFD6dv8xxuej/LIPBxgrq0KmcI5ufP328/fA@TdM3/YuuBcbwJ5gwSYFwx2hKrUwwgGCFDXgfmmoPP@ujqiFmqjU1/mCNFcysLSkY9AAgWNjCwJKMsS09Qj4qA/fYkIdTu4V5o7G9exAntaI8V2bvsKMHa6GjIvhmTU7s3yywohqmbE8tJcaDhiibIYvp5i@ViCZYqcyZzK8yK9vAA29V3ZmYaLhnoi6P3RILxM6DtAZVVsIC9/t2nidvlEHYHNh0Du7YOySIiLMDN/9TRL6SroHKpW/ACSvTDexdezCuOqyLtjcRhDaMR3M8qhym9qTaVr6igcgyq2d65POQdpSsvKbwW9@N0v7gby9mZSTZwTAE93/pCwzDIawtSwqXfw "Wolfram Language (Mathematica) – Try It Online")
[Answer]
# Excel, 96 bytes
After too much time wasted trying other approaches, have implemented @Eduardo Paez's approach:
```
=CHAR(FIND(MID(A1,5,1)&MID(A1,3,1),"her DbMbdvsv tdeicsm hnhltirac c i uCyrbOyCmeoie nMn")/2+65)
```
[Answer]
# ///, ~~390~~ 231 bytes
```
/gg/U/
/a///b///c///d///e///f///g///h///i///j///k///l///m///n///o///p///q///r///s///t///u///v///w///x///y///z//
/ F//
/A //
/ G//
/ M//
/M //
/J B/X/
/J //
/L //
/ R//
/R C/Y/
/S C/Z/
/B D/K/
/ B//
/ J//
/ T//
/S W/I/
/R O/N/
/JU/U/
/R //
/E P/H/
/PC/Q/
```
[Try it online!](https://tio.run/##HZHbwpMwEITv8xT7BvsMhR60Fou0v796l8IKkXSjIaXiy9cJF9/ksMnMBiZvp0Gm14v7nt@YLTPfQAs6IOAn6MEAHPgFRuDBHSgI4Df4AyKYQAIPMIMn@AsW8A/QHrKhPDtkqSBVXh6p4G95wPy01htIQyV/Z75g@MFc0JY/oVLk8jHLlXPxnT/mo2f@DIO3/JwmO@yo5g/Mdclf2GyipMHSPlodvVOz8XSIImoau1A52OhlMk24SUxUe6vJ7PzsJqqjTF4WU7l2pKPte4nmYu9UhjCKuTq1dH1Exe4xDEonUQ1q9lG6zglVEttHxG0bZ6d0sIuYItyoynnLOt0uSDOXO@wWQgNOJxicE7KbbKL96qzoEr/MXJLMMH4P2iFzl5JFV3f0vioVMTzVbO3sOirC04mp7cNT1ZY2JkXkV6tUhRhdTjm5lLxQ41p8gC6/cbDiYdiOudyEhc7xth7NeznXeaxer/8 "/// – Try It Online")
231 bytes after removing the newlines.
This is very long, but /// cannot handle different characters generically. In other words, /// does not support regex.
]