26 певцов, 26 писем

34

Согласно 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 возможных входов.
  • Это код-гольф , поэтому выигрывает самый короткий ответ в байтах!
code-golf hashing Arnauld
источник
(Удален вход в песочницу.)
Арно
17
Уважаемый Rolling Stone: Боб Дилан действительно один из величайших музыкантов всех времен. Но великий певец ?
Луис Мендо
@LuisMendo Я немного соленый о некоторых из этих вариантов , а также ( кашель кашель , где Стив Тайлер кашель )
Lord Фаркваарду
@LordFarquaad Стив Тайлер - № 99 ¯ \ _ (ツ) _ / ¯
Арно
это может кому-то помочь, но у меня нет навыков компьютерной графики, чтобы использовать информацию: 1-6, 1-8 и 3-5 букв имен являются уникальными комбинациями.
Jeutnarg

Ответы:

2

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строки.

Sanchises
источник
23

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)

TFeld
источник
Я думаю, что вы можете сократить (i>31)до i/32, и т. Д.
xnor
21

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

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

Феликс Палмен
источник
13

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)

Попробуйте онлайн!

овс
источник
1
интересно узнать, как ты это сочинил
Sarge Borsch
2
@SargeBorsch hash (n) вычисляет уникальное целое число для каждого имени. Операции по модулю сохраняют уникальность этих целых, но снижают их стоимость. Вторая часть ( chr(65+i-i/25*2-i/29*21+i/35*2)) похожа на ответ TFelds . Операции по модулю выполняются скриптом, который я уже использовал здесь и здесь .
овс
10

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) ));
Развернуть фрагмент

п-х
источник
Там может быть более короткая функция хеширования, но мне нравится идея попробовать что-то, что может сделать человек. Однако я бы хотел, чтобы вы использовали функцию фрагмента кода вместо ссылки на JSFiddle.
17
@trlkly Теперь я использовал функцию фрагмента кода.
NL-X
7

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

Попробуйте онлайн!

Люк Стивенс
источник
1
Хороший ответ, +1 от меня. В настоящее время я также работаю над решением для Java, создавая сценарий. Кстати, вы можете {a+=i;}a+=i;
Кевин Круйссен
1
@KevinCruijssen Приветствия, не могу поверить, что я пропустил это! Я написал скрипт, чтобы попытаться найти «магическое число», которое дало бы мне уникальные значения от 0 до 25, но лучшее, что я мог сделать, было 24, поэтому в конце были операторы if.
Люк Стивенс
1
Хм, кстати, так как вы используете Java 8, вы также можете играть char g(String s)в гольф s->. Я изменил ваш TIO, чтобы показать, как это сделать, если вы привыкли только к методам Java 7.
Кевин Круйссен
Спасибо, я никогда не осознавал, что ты можешь сделать это, я
Люк Стивенс
Хахаха, ты можешь сказать, что я новичок в этом
Люк Стивенс
5

Python 3, 132 99 96 байт

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

Попробуйте онлайн!

Не блестяще играл в гольф, но я решил попробовать.

-33 байта благодаря модификациям, сделанным TFeld.
-3 байта, используя findвместо indexovs.

LyricLy
источник
Вы можете сэкономить 6 байтов с помощью sum(map(ord,m)), также я добавил Арету Франклин для 128 байтов
TFeld
И вы можете использовать chr(97+...)вместо ascii_lowercase: 99 байтов
TFeld
1
Как насчет объяснения?
Мацеманн
3
Объяснение: sum(map(ord,m))складывает значения ASCII символов в строке m(дает целые числа в диапазоне 702–1506). Затем, вызывая chrего, он преобразуется в символ (Unicode) с таким номером: chr(702)is ʾ to chr(1506) = עи много между ними. Это решение просто ищет этот символ в списке всех возможных (26) таких символов, чтобы получить индекс (0–26), а затем возвращает символ с кодом ASCII 97 + этот индекс (так что «a» - «z»).
ShreevatsaR
1
Ваше текущее решение все еще содержит 99-байтовую версию. Вы хотели использовать версию OVS?
NL-X
5

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

может стать еще короче с другим модулем.

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

Сохраните в файл и запустите как канал -nFили попробуйте онлайн .

Titus
источник
2
Арета Франклин и Пол Маккартни выводят данные Wо ваших тестовых примерах, но Xвыходных данных нет . Не знаю, является ли это ошибкой в ​​самом коде или просто попытаться преобразовать его онлайн :)
crazyloonybin
1
Исправлена ​​опечатка @crazyloonybin. Спасибо за подсказку.
Тит
Так как мне это запустить? Ваш код "попробуйте онлайн" не использует эту <?=часть. И «Беги как труба» я не получаю работу. Кроме того, я получаю уведомления при попытке запустить его из командной строки.
NL-X
@Titus: В CodeGolf вы должны предоставить полную функцию или приложение, которое генерирует (только) желаемый результат. Я знаком с <?=... Итак, мой вопрос по-прежнему, как мне запустить ваш код (из командной строки)? Я не могу $argnпередать его в командной строке ... Все мои попытки до сих пор либо дают артефакты, но все еще, кажется, требуют больше кода для его запуска.
NL-X
@ nl-x Ваш PHP выдает уведомления, это потому, что вы не дали ему опцию n:echo <input> | php -nF <scriptfilename>
Тит
4

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

Попробуйте онлайн

Науэль Фуйе
источник
Хороший подход! Я думаю, что вам нужно написать / забить целую вызываемую функцию, хотя?
Феликс Пальмен
@FelixPalmen, это Perl-программа, которую можно назвать встроенной: perl -pe '$_=crypt$_,mO;/..(.)/;$_=$1;y/035eft/AHPRXZ/;$_=lc'добавление ссылки на tio
Nahuel Fouilleul
Ницца! Искал подобный подход, используя, $1^$2но не думал использовать crypt... Вы можете сэкономить 4 байта с некоторым повторным заказом: попробуйте онлайн!
Дом Гастингс
4

Python 2, 50 43 байта

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

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

Попробуйте онлайн!

Примечание: это зависит от hashвстроенного и не будет работать во всех реализациях

KSab
источник
43 байта:lambda n:chr(hash(n)%2354%977%237%54%26+65)
japh
@japh Отлично! Моя проверка на python brute force явно была недостаточно быстрой;)
KSab
3

Рубин, 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"]
Уровень реки St
источник
3

Октава , 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 байтов путем суммирования с использованием умножения матриц.
Том Карпентер
источник
Умный подход, может быть, слишком умный? 53 байта, основываясь на моем ответе
MATL
@ Возможно, но это был подход, который я предложил ¯_ (ツ) _ / ¯. Вы можете опубликовать свою версию в качестве отдельного ответа.
Том Карпентер
Я понял, и я согласен, что более интересно использовать разные подходы, чем просто копировать самый короткий подход. Я просто хотел сравнить подходы, я думаю, что ваш более умный, но я полагаю, что набор данных только что позволил простой подход на основе модов (не уверен, что это совпадение или статистически вероятно)
Sanchises
3

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]))
Развернуть фрагмент

edc65
источник
Вы можете упомянуть, что он работает только в Chrome из -за зависимых от реализации приближений в parseInt().
Arnauld
@ Arnauld спасибо, я не знал.
edc65
3

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.

JAPH
источник
2

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))
Развернуть фрагмент

Эдуардо Паес Рубио
источник
Очень удачная комбинация, которую вы нашли!
Joyal
ааа да. конечно. У меня есть нечто очень похожее, но вместо добавления символа для возврата в строку, положение вхождения может сохранить 25 символов. Умная!
NL-X
1

///, 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 байт после удаления новых строк.

Это очень долго, но /// не может обрабатывать разные символы в общем. Другими словами, /// не поддерживает регулярное выражение.

user202729
источник
0

Excel, 96 байт

После того, как слишком много времени было потрачено на попытки применения других подходов, внедрили подход @Eduardo Paez:

=CHAR(FIND(MID(A1,5,1)&MID(A1,3,1),"her DbMbdvsv tdeicsm hnhltirac c i uCyrbOyCmeoie nMn")/2+65)
Wernisch
источник