Согласно 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 для Боба Дилана , то он не может вернуть 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 (в порядке списка Pastebin).

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.

Примечание: 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 Ик J Аггер, я проверяю для Майкла Джексона специально (только один с 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вместо indexovs.}

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 /

$ = crypt $ , DT; / .. (.) /; $ = $ 1; y / 01268JVW / hlmpqsux /; $ = lc

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

Благодаря комментарию Dom можно было сохранить еще 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, принимает их мод 98, а затем мод 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]и затем выполняющая mod 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-only используя логическое индексирование 'A':'Z'вместо find.
• Сохранено 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;}

Тот же подход, что и в ответе KSab . 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))

Wolfram Language (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)