Theo RollingStone , dưới đây là 26 ca sĩ vĩ đại nhất mọi thời đại:

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

Bạn có thể lấy đây là danh sách các chuỗi ở đây .

Bài tập

Với một tên ca sĩ, in hoặc trả lại một lá thư từ Ađể Zxác duy nhất ca sĩ này. (Nếu mã của bạn trả về A cho Bob Dylan , thì nó không thể trả lại A cho bất kỳ ca sĩ nào khác.)

Trái ngược với những thách thức tương tự khác, việc lập bản đồ tùy thuộc vào bạn miễn là không va chạm.

Quy tắc

• Đầu vào được đảm bảo là một trong 26 tên ca sĩ được liệt kê ở trên với chính tả này và không có bất kỳ khoảng trắng hàng đầu hoặc dấu.
• Bạn có thể xuất chữ cái bằng chữ thường hoặc chữ hoa. Nhưng nó phải nhất quán.
• Bạn được khuyến khích cung cấp một bộ thử nghiệm cho tất cả 26 đầu vào có thể.
• Đây là môn đánh gôn , vì vậy câu trả lời ngắn nhất bằng byte sẽ thắng!

MATL , 28 byte

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

Hãy thử trực tuyến!

Giải trình

s98\40\

Hoàn toàn có được chuỗi đầu vào. Tính tổng các ký tự của chuỗi đầu vào và thực hiện mô đun 98 theo sau là mô đun 40. Kết quả theo một trong các số sau: 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 (theo thứ tự của danh sách Pastebin).

2Y2'ijkl o qst uz'h

Đẩy bảng chữ cái (chữ thường) với 2Y2. Điều này quan tâm đến các số trong phạm vi [1,26]. Tuy nhiên, một số số bị thiếu và chúng tôi có số lên tới 38. Do đó, chúng tôi nối thêm ( h) một chuỗi chăm sóc các số cao hơn, bằng cách ánh xạ các số này thành các chữ cái 'mất tích'. Các không gian có thể là bất cứ điều gì, tôi đã sử dụng chữ in hoa trong chương trình ban đầu của mình để thuận tiện cho riêng tôi.

w)

Bây giờ chúng ta có thể lập chỉ mục số từ bước đầu tiên vào chuỗi từ bước thứ hai với ). Chúng tôi sử dụngw để có được các đối số theo đúng thứ tự. Mặc dù có vẻ như chúng tôi sử dụng lập chỉ mục dựa trên 0 (các số thay đổi từ 0 đến 38 và chuỗi dài 39 ký tự), nhưng thực tế thực tế phức tạp hơn một chút: chúng tôi sử dụng lập chỉ mục mô-đun dựa trên 1, một tính năng duy nhất để TOÁN. Điều này có nghĩa là 1các chỉ mục đến a, 38thực sự lập chỉ mục uvà 0lập chỉ mục đến cuối cùng zcủa chuỗi.

Python 2 , 80 71 byte

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

Hãy thử trực tuyến!

Các khoản tiền được điều chế cho số giữa 0 và38

Các số lớn hơn 25 sau đó được dịch chuyển để điền vào chỗ trống như bên dưới (trình tự sắp xếp được hiển thị):

  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

Trừ đi 18nếu 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

Thêm 3nếu 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

Trừ đi 8nếu 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

Cung cấp cho chuỗi 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

Chúng sau đó được chuyển đổi thành A-Zvớichr(i+65)

Thường trình mã máy 6502 (C64), 83 byte

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

Đây là mã độc lập với vị trí, chỉ cần đặt nó ở đâu đó trong RAM và nhảy tới đó, ví dụ như sử dụng syslệnh.

Bản demo trực tuyến (tải đến$C000/49152).

Cách sử dụng: sys49152,"[name]" vd sys49152,"Aretha Franklin".

Quan trọng: Nếu chương trình được tải từ đĩa (như trong bản demo trực tuyến), newtrước tiên hãy ra lệnh! Điều này là cần thiết bởi vì tải một chương trình máy bỏ qua một số con trỏ C64 BASIC.

Lưu ý: C64 theo mặc định ở chế độ không có chữ thường - để có thể nhập tên dễ đọc , trước tiên hãy chuyển sang chế độ chữ thường bằng cách nhấn SHIFT+ CBM.

Giải trình

Trên thực tế, thách thức là tìm ra hàm băm hoàn hảo tối thiểu cho các tên này; đối với C64, tôi phải tìm một thứ dễ tính toán trong các thao tác 8 bit đơn giản. Dưới đây là danh sách tháo gỡ nhận xét:

.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

Bộ kiểm tra (C64 BASIC, chứa thường trình mã máy theo datadòng)

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

Bản demo trực tuyến của bộ thử nghiệm .

Python 2 , 68 byte

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

Hãy thử trực tuyến!

Javascript, 138 132 ký tự

Vì tất cả tên viết tắt là duy nhất, ngoại trừ MJ= M ichael J ackson / M ick J agger, tôi kiểm tra cụ thể Michael Jackson (người duy nhất có hvị trí thứ 4) và cho tất cả các tên khác tôi đã tạo một chuỗi có chữ cái đầu theo sau bởi một lá thư độc đáo.

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

Đoạn mã

Hãy thử nó ở đây:

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 byte

Không quá tồi tệ cho một đệ trình java!

Cảm ơn Kevin vì đã tiết kiệm cho tôi rất nhiều byte với các biểu thức lambda!

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

Hãy thử trực tuyến!

Python 3, 132 99 96 byte

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

Hãy thử trực tuyến!

Không chơi golf xuất sắc, nhưng tôi nghĩ tôi sẽ thử.

^{-33 byte nhờ sửa đổi được thực hiện bởi TFeld.
-3 byte bằng cách sử dụng findthay vì indexnhờ vào các lò nướng.}

PHP 90 88 86 72 + 1 byte

thậm chí có thể trở nên ngắn hơn với một modulo khác.

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

Lưu vào tập tin và chạy như ống với -nFhoặc thử trực tuyến .

Perl, 56 , 54 , 50 , 46 +1 (-p) byte

$ = mật mã $ , DT; / .. (.) /; $ _ = $ 1; y / 01268ADIJNVW / adhilmnpqsux /

$ = mật mã $ , DT; / .. (.) /; $ = $ 1; y / 01268JVW / hlmpqsux /; $ = lc

$ = mật mã $ , mO; / .. (.) /; $ = $ 1; y / 035eft / AHPRXZ /; $ = lc

Nhờ nhận xét của Dom có ​​thể tiết kiệm thêm 4 byte, cũng được đổi thành chữ hoa để phù hợp với các yêu cầu tốt hơn.

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

Dùng thử trực tuyến

Con trăn 2, 50 43 byte

Tín dụng cho japh cho phiên bản mới

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

Hãy thử trực tuyến!

Lưu ý: Điều này phụ thuộc vào hashnội dung và sẽ không hoạt động trong tất cả các triển khai

Ruby, 63 byte

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

Thêm mã ascii của đầu vào, đưa chúng mod 98 và sau đó mod 66 để có được một trong 26 số duy nhất ntrong phạm vi 0,65. Số thập lục phân khổng lồ chứa một 1bit ở mỗi trong số 26 vị trí này, do đó, bằng cách chuyển quyền nó bằng cách nchúng tôi có được một số có 1,26 1bit trong đó. Chúng tôi đếm1 bit bằng cách thêm mã ascii và lấy mod 48, sau đó thêm 64 và chuyển đổi thành mã ASCII.

Chương trình kiểm tra

các map lặp qua các ca sĩ in mã thư và ca sĩ. Sau đó, nó trả về một mảng các mã chữ cái, được chỉnh sortsửa để chứng minh rằng mỗi chữ cái được sử dụng một lần.

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

Đầu ra

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

Octave , 85 83 80 74 byte

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

Sự lộn xộn của một ẩn danh này là kết quả của một số sự lộn xộn trong MATLAB khi cố gắng tìm một cách tốt để mã hóa dữ liệu.

Về cơ bản sau khi phân tích nhanh, chỉ cần các chữ cái 1,2 và 8 của chuỗi đầu vào (chuỗi nhỏ nhất là 8 ký tự, vì vậy chúng tôi rất tốt) là cần thiết để tạo ra một giá trị duy nhất từ ​​mỗi đầu vào. Phần khó sau đó là chuyển đổi giá trị duy nhất đó thành một thứ có thể sử dụng được.

MATLAB rất tệ trong việc nén dữ liệu, vì vậy tôi phải tìm một cách khác để lập bản đồ tra cứu. Tôi bắt đầu thử tìm một số hàm trên ba chữ cái đầu vào dẫn đến một giá trị duy nhất cũng là giá trị ASCII có thể in được để tôi có thể nhúng ánh xạ vào một chuỗi một ký tự cho mỗi đầu vào.

Nó chỉ ra rằng ma trận nhân các ký tự trong chỉ mục [1 2 8]với ma trận số nguyên [1;15;47]và sau đó thực hiện mod 124 kết quả trong các giá trị duy nhất mà tất cả ASCII có thể in được (và không có 'ký tự nào có thể làm hỏng chuỗi ký tự chuỗi). Làm hài lòng bản đồ kết thúc với TIOnó là hoàn toàn tình cờ. Điều thú vị là đây là bản đồ duy nhất cho phương trình này cung cấp 26 ký tự ASCII có thể in duy nhất.

Vì vậy, về cơ bản đó là bản đồ tra cứu và tính toán của tôi. Thực hiện tra cứu chỉ đơn giản là một trường hợp thực hiện tính toán và so sánh với ánh xạ. Thêm vào 'A'-1chỉ mục trong bản đồ sẽ tạo ra ký tự AZ.

Bạn có thể thử trực tuyến trên TIO, trong đó hiển thị ánh xạ đầy đủ của đầu vào và đầu ra. Để hoàn thiện, ánh xạ đầy đủ cũng ở bên dưới:

'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

• Đã lưu 2 byte ánh xạ tinh chỉnh để loại bỏ +32.
• Đã lưu 3 byte bằng cách chỉ sử dụng Octave bằng cách lập chỉ mục logic 'A':'Z'thay vì tìm.
• Đã lưu 6 byte bằng cách thực hiện tổng các phép nhân bằng cách nhân ma trận.

JavaScript (Chrome), 102

Lưu ý Thật không may, nó chỉ hoạt động trong Chrome, vì các xấp xỉ phụ thuộc vào triển khai trong parseInt () (cảm ơn @Arnauld)

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

Tôi đã tìm một hàm băm, lấy một lát của mỗi tên, chuyển đổi thành số bằng cách sử dụng cơ sở 36 và sau đó áp dụng một modulo.

Tôi đã sử dụng mã này để tìm kiếm hàm băm tốt nhất:

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

Và kết quả:

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

Hàm băm tốt nhất cung cấp 26 giá trị khác nhau trong khoảng từ 0 đến 50, nhưng tôi đã sử dụng một giá trị khác, với 1 giá trị trùng lặp nhưng phạm vi nhỏ hơn.

Kiểm tra

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 byte

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ách tiếp cận tương tự như câu trả lời của KSab . C không cung cấp hashhàm chuỗi như Python. Hay không?

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

Hãy thử trực tuyến!

htrả về intgiá trị có mã ASCII cho A .. Z.

Javascript, 98 byte

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

Tôi thấy rằng sự kết hợp của ký tự thứ 2 và thứ 4 của các tên là duy nhất cho mỗi tên.

Do đó, tôi tạo ra một chuỗi với sự kết hợp của name[4] + name[2], không name[2] + name[4]hoặc tôi sẽ có sự lặp lại của nhóm char ehcủa tên đầu tiên Aretha Franklin ehvà khi Smokey Robinson và Johnny Cashoehn được nối.

Tôi chỉ có thể di chuyển Johnny Cash đến một vị trí khác của chuỗi và có được một ánh xạ khác, nhưng ghép nối ký tự thứ 4 và thứ 2 theo thứ tự này để tránh xung đột và giữ nguyên thứ tự dữ liệu mà không cần thêm độ dài cho giải pháp. Vì vậy, tôi quyết định đi theo cách đó (đó chỉ là sở thích cá nhân)

Tôi tìm kiếm vị trí nối của chữ cái thứ 4 và thứ 2 của tham số đã cho trong chuỗi và chia nó cho 2 để tôi nhận được một số từ 0 đến 25. Sau đó, tôi thêm 10 và chuyển nó thành chuỗi từ cơ sở 36, trong đó 10 tương ứng avà 35 đếnz

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

Ngôn ngữ Wolfram (Mathicala) , 101126 byte

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

+32 dường như dẫn đến hashtable ngắn nhất trong Mathicala InputForm .

Hãy thử trực tuyến!

///, 390 231 byte

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

Hãy thử trực tuyến!

231 byte sau khi loại bỏ các dòng mới.

Điều này rất dài, nhưng /// không thể xử lý các ký tự khác nhau một cách khái quát. Nói cách khác, /// không hỗ trợ regex.

Excel, 96 byte

Sau quá nhiều thời gian lãng phí để thử các cách tiếp cận khác, đã triển khai phương pháp của @Eduardo Paez:

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