За інформацією RollingStone , нижче 26 найкращих співаків усіх часів:

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

Ви можете отримати це як список рядків тут .

Завдання

Давши ім'я співака, роздрукуйте або поверніть листа, Aв Zякому однозначно ідентифікує цього співака. (Якщо ваш код повертає A для Bob Dylan , він не може повернути A жодному іншому співаку.)

На відміну від інших подібних проблем, картографування залежить від вас , якщо це не зіткнення.

Правила

• Гарантується, що це одне з 26 перелічених імен співаків з цим точним написанням та без жодного провідного чи зворотного пробілу.
• Ви можете вивести літеру або малі, або великі регістри. Але воно повинно бути послідовним.
• Вам пропонується надати тестовий набір для всіх 26 можливих входів.
• Це код-гольф , тому найкоротша відповідь у байтах виграє!

MATL , 28 байт

s98\40\2Y2'ijkl o qst uz'hw)

Спробуйте в Інтернеті!

Пояснення

s98\40\

Неналежне отримання вхідного рядка. Підсумовуйте символи вхідного рядка і виконайте його за модулем 98 з наступним модулем 40. Результати в одному з наступних чисел: 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 (у порядку списку вставки).

2Y2'ijkl o qst uz'h

Натисніть алфавіт (малі) 2Y2. Це враховує числа в діапазоні [1,26]. Однак деякі цифри відсутні, і у нас є цифри до 38. Отже, ми додаємо ( h) рядок, що піклується про більш високі числа, шляхом зіставлення цих чисел на "пропущені" літери. Пробіли можуть бути будь-якими, я використовував великі літери в своїй оригінальній програмі для власної зручності.

w)

Тепер ми можемо проіндексувати число від першого кроку до рядка з другого кроку за допомогою ). Ми використовуємо wдля отримання аргументів у правильному порядку. Хоча може здатися, що ми використовуємо індексацію на основі 0 (цифри варіюються від 0 до 38, а рядок - 39 символів), насправді дещо складніше: ми використовуємо модульну індексацію на основі 1, яка є унікальною для MATL. Це означає, що 1індекси до a, 38власне, індексуються до uта 0індексуються до фіналу zрядка.

Python 2 , 80 71 байт

def f(s):i=sum(map(ord,s))%98%40;return chr(i-i/26*18+i/32*3-i/37*8+65)

Спробуйте в Інтернеті!

Сума порядкових порядків дає числа між 0і38

Числа, що перевищують 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

Віднімаємо, 18якщо 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

Додати, 3якщо 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

Віднімаємо, 8якщо 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

Що дає послідовність 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

Потім вони перетворюються в A-Zсchr(i+65)

Рутинна машина-код 6502 (C64), 83 байти

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

Це незалежний від позиції код, просто покладіть його десь в оперативній пам’яті і перескочіть туди, наприклад, використовуючи sysкоманду.

Демонстрація в Інтернеті (завантаження в$C000/49152).

Використання:, sys49152,"[name]" напр sys49152,"Aretha Franklin".

Важливо: Якщо програма завантажувалася з диска (як, наприклад, в демонстрації в Інтернеті), newспочатку видайте команду! Це необхідно, оскільки завантаження машинної програми знищує деякі вказівники C64 BASIC.

Примітка: C64 за замовчуванням знаходиться в режимі без малих літер - для того, щоб можна було вводити читабельні імена, спочатку перейдіть у режим малих літер, натиснувши SHIFT+ CBM.

Пояснення

Завдання полягає в тому, щоб знайти мінімально ідеальну хеш-функцію для цих імен; для C64, мені довелося знайти той, який легко піддається обчисленню в простих 8-бітових операціях. Ось коментований список розбирання:

.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

Набір тестів (C64 BASIC, що містить порядок машинного коду в dataрядках)

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

Онлайн демонстрація тестового набору .

Python 2 , 68 байт

def f(n):i=hash(n)%337%125%45;return chr(65+i-i/25*2-i/29*21+i/35*2)

Спробуйте в Інтернеті!

Javascript, 138 132 символів

Оскільки всі ініціали унікальні, за винятком MJ= M ichael J ackson / M ick J agger, я перевіряю Майкла Джексона спеціально (єдиний з h4-ї позиції), і для всіх інших імен я створив рядок з наступними ініціалами унікальним листом.

s=>s[3]=='h'?'y':"AFaRCbEPcSCdJLeMGfBDgORhSWiJBjPMCkLRlROmAGnRPoMJpTTqFMrBMsSRtJCuEJvDBwVMxJWz".split(s.replace(/[^A-Z]/g,''))[1][0]

Знімок коду

Спробуйте тут:

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) ));

Java (OpenJDK 8) , 128 126 115 113 байт

Не надто пошарпаний для подання Java!

Дякую Кевіну, що врятував мені цілу партію байтів із лямбдаськими виразами!

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);}

Спробуйте в Інтернеті!

Python 3, 132 99 96 байт

lambda m:chr(98+"ԇ̲ЙГ̫ѼӿИԸՋжʾҍϴЬֺΝעЕΞϾҞ֜ӣ֪".find(chr(sum(map(ord,m)))))

Спробуйте в Інтернеті!

Не грав у гольфі блискуче, але я подумав, що піду цьому.

^{-33 байти завдяки модифікаціям, внесеним TFeld.
-3 байти, використовуючи findзамість indexподяки ovs.}

PHP, 90 88 86 72 + 1 байт

може стати ще коротшим за допомогою іншого модуля.

<?=strtr(chr(hexdec(substr(md5($argn),0,2))%65+58),"^<adins",bcfgqvx)&_;

Збережіть у файлі та запустіть як трубу -nFабо спробуйте в Інтернеті .

Perl, 56 , 54 , 50 , 46 +1 (-p) байт

$ = crypt $ , DT; / .. (.) /; $ _ = $ 1; y / 01268ADIJNVW / adhilmnpqsux /

$ = скріп $ , DT; / .. (.) /; $ = $ 1; у / 01268JVW / hlmpqsux /; $ = lc

$ = скріп $ , mO; / .. (.) /; $ = $ 1; y / 035eft / AHPRXZ /; $ = lc

Завдяки коментарю Дома вдалося зберегти ще 4 байти, також змінені на великі регістри, щоб відповідати кращим вимогам.

$_=crypt$_,mO;y/035eft/AHPRXZ/;/..(.)/;$_=uc$1

Спробуйте це в Інтернеті

Python 2, 50 43 байт

Кредит JAPH для нової версії

lambda n:chr(hash(n)%2354%977%237%54%26+65)

Спробуйте в Інтернеті!

Примітка. Це залежить від hashвбудованого і працюватиме не у всіх реалізаціях

Рубін, 63 байти

->s{((0x3c4001c151861b27d>>s.sum%98%66).to_s(2).sum%48+64).chr}

Додає коди ascii на вхід, приймає їх mod 98, а потім mod 66, щоб отримати одне з 26 унікальних чисел nу діапазоні 0..65. Величезний шістнадцятковий номер містить 1біт у кожному з цих 26 місць, тому, змінюючи його правами, nми отримуємо число з 1..26 1бітами в ньому. Ми підраховуємо 1біти, додаючи коди ascii і приймаючи mod 48, потім додаємо 64 і перетворюємо в ASCII код.

Тестова програма

mapперебирає співаків друкуючим літерний код і співачку. Потім він повертає масив буквених кодів, який sortредагується, щоб продемонструвати, що кожна буква використовується один раз.

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

Вихідні дані

["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"] 

Октава , 85 83 80 74 байт

@(n)('A':'Z')(mod(n([1 2 8])*[1;15;47],124)=='#iZo,gp<C&4Y1!8-G`Kn3wtTIO')

Цей безлад анонімного є результатом деякого возитися в MATLAB, намагаючись знайти хороший спосіб кодування даних.

В основному після швидкого аналізу потрібні лише букви 1,2 та 8 вхідного рядка (найменший рядок - 8 знаків, тому ми хороші) для отримання унікального значення з кожного вводу. Потім важка частина перетворює це унікальне значення на щось корисне.

MATLAB страшний при стисненні даних, тому мені довелося шукати інший спосіб зробити відображення пошуку. Я намагався знайти деяку функцію на трьох вхідних літерах, що призвело до унікального значення, яке також було значення для друку ASCII, щоб я міг вбудовувати відображення в рядок з одного символу на кожен вхід.

Виявляється, що матриця, що множує символи в індексі [1 2 8]на цілу матрицю, [1;15;47]а потім виконує мод 124, приводить до унікальних значень, які всі друкуються ASCII (і жоден не є 'символом, який би підсилював рядкові букви). Приємно закінчується відображення, з TIOяким цілком випадково. Цікаво, що це єдине відображення цього рівняння, яке дає 26 унікальних символів для друку ASCII.

Так що в основному це моє пошукове відображення та розрахунок. Здійснення пошуку - це просто випадок виконання обчислення та порівняння з відображенням. Додавання 'A'-1до індексу на карті призводить до символу AZ.

Ви можете спробувати його в режимі он-лайн на TIO, де показано повне відображення входів та виходів. Для повноти повне відображення також нижче:

'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

• Збережено 2 байти, налаштовуючи відображення для видалення +32.
• Збережено 3 байти, зробивши лише Octave, використовуючи логічне індексування, 'A':'Z'а не пошук.
• Збережено 6 байт, зробивши суму множень за допомогою матричного множення.

JavaScript (Chrome), 102

Примітка На жаль, він працює лише в Chrome, через наближення до реалізації в parseInt () (залежно від @Arnauld)

s=>s[0]=='L'?'z':"ab.c..defghijklmn...o..pqrst.u.vwxy"[parseInt(s.replace(/ /,'o').slice(0,14),36)%35]

Я шукав хеш-функцію, взяв фрагмент кожного імені, перетворив на числа за допомогою бази 36 та застосував модуль.

Я використовував цей код, щоб шукати найкращий хеш:

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)
      }

І результати:

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

Найкраща хеш-функція дає 26 різних значень між 0 і 50, але я використовував інше, з 1 дублікатом, але меншим діапазоном.

Тест

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]))

C, 65 55 49 байт

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;}

Той самий підхід, що і у відповіді К.Саба . C не забезпечує функцію рядка, hashяк Python. Або це?

h(char*s){return*(long*)s%2004%857%361%94%26+65;}

Спробуйте в Інтернеті!

hповертає intзначення, значення якого є кодами ASCII A .. Z.

Javascript, 98 байт

s=l=>("heCysvCm hirDb iiesm ultOyr rb c ndeMbeonh tdvMnacic".indexOf(l[4]+l[2])/2+10).toString(36)

Я виявив, що поєднання 2-го та 4-го символів імен є унікальним для кожного з них.

Тому я створюю рядок із комбінаціями " name[4] + name[2]ні", name[2] + name[4]або я б повторив чарівну групу ehна ім'я Арета Франклін, ehі коли Смокі Робінсон та Джонні Кеш oehnоб'єдналися.

Я міг би просто перенести Джонні Кеша в інше положення рядка і отримати інше відображення, але об'єднання 4-го та 2-го символів у цьому порядку уникає зіткнення та залишає порядок набору даних неушкодженим, не додаючи рішення більше довжини. Тому я вирішив піти цим шляхом (це лише особисті переваги)

Я шукаю позицію конкатенації 4-ї та 2-ї літери даного параметра в рядку і ділю його на 2, щоб я отримав число між 0 і 25. Потім додаю 10 і перетворюю його в рядок з бази 36, де 10 відповідає aі 35 до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))

Мова Вольфрама (Mathematica) , 101126 байт

Alphabet[][[#&@@#&@@Position[(t=ToCharacterCode)@"nZ-Be_;f%d^q 0w@x~KDaLJ&`k",Total@t@#~Mod~98+32]]]&

+32Здається, що веде до найкоротшого перемішування хештелю в Mathematica InputForm.

Спробуйте в Інтернеті!

///, 390 231 байт

/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/

Спробуйте в Інтернеті!

231 байт після видалення нових рядків.

Це дуже довго, але /// не може обробляти різні символи загалом. Іншими словами, /// не підтримує регулярний вираз.

Excel, 96 байт

Після надто багато часу, пробуючи інші підходи, застосував підхід @Eduardo Paez:

=CHAR(FIND(MID(A1,5,1)&MID(A1,3,1),"her DbMbdvsv tdeicsm hnhltirac c i uCyrbOyCmeoie nMn")/2+65)