रोलिंगस्टोन के अनुसार , सभी समय के 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

डियर रॉलिंग स्टोन: बॉब डायलन वास्तव में अब तक के सबसे महान संगीतकारों में से एक हैं। लेकिन एक महान गायक ?

— लुइस मेंडो

@LuisMendo मैं इन विकल्पों में से कुछ के बारे में थोड़ा नमकीन हूँ ( खाँसी की खाँसी जहाँ स्टीव टायलर खाँसी है )

— लॉर्ड फरक्वाड

@LordFarquaad स्टीव टायलर # 99 (\ _ (_) _ / ¯

— Arnauld

यह किसी की मदद कर सकता है, लेकिन मेरे पास जानकारी का उपयोग करने के लिए सीजी कौशल नहीं है: 1-6, 1-8, और नामों के 3-5 अक्षर अद्वितीय संयोजन हैं।

— जेतुनार्ग

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 (पास्टबिन सूची के क्रम में)।

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

पायथन 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 बिट संचालन में आसानी से गणना करने योग्य हो। यहाँ एक टिप्पणी disassembly सूची है:

.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 बुनियादी, `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

पायथन 2 , 68 बाइट्स

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

इसे ऑनलाइन आज़माएं!

— OVS
स्रोत

1

यह जानने के लिए कि आपने यह कैसे

— लिखा है

2

@SargeBorsch हैश (n) प्रत्येक नामों के लिए एक अद्वितीय पूर्णांक की गणना करता है। मोडुलो ऑपरेशन अभी भी उन चींटियों को अद्वितीय रखते हैं, लेकिन उनके मूल्य को कम करते हैं। दूसरा भाग ( chr(65+i-i/25*2-i/29*21+i/35*2)) TFelds उत्तर के समान है । मॉडुलो ऑपरेशंस को एक स्क्रिप्ट द्वारा ब्राइट किया जाता है जिसे मैंने पहले ही यहाँ और यहाँ इस्तेमाल किया है ।

— ओक्ट्स

10

जावास्क्रिप्ट, 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) ));

स्निपेट का विस्तार करें

— nl-एक्स
स्रोत

एक छोटा हैशिंग फ़ंक्शन हो सकता है, लेकिन मुझे ऐसा कुछ करने की कोशिश करना पसंद है जो एक मानव कर सकता है। हालाँकि, मुझे लगता है कि आप JSFiddle से लिंक करने के बजाय कोड स्निपेट सुविधा का उपयोग करेंगे।

— त्रिकली

@trlkly मैंने अभी कोड स्निपेट सुविधा का उपयोग किया है।

— nl-x

7

जावा (ओपनजेडके 8) , 128 126 115 113 बाइट्स

एक जावा प्रस्तुत करने के लिए भी जर्जर नहीं!

मुझे केम्बे के लिए धन्यवाद लैम्ब्डा अभिव्यक्ति के साथ बाइट्स की एक पूरी बचत करने के लिए!

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। मैं वर्तमान में भी एक स्क्रिप्ट बनाने के द्वारा एक जावा समाधान पर काम कर रहा हूँ .. हालांकि अभी तक कोई भाग्य नहीं। Btw, आप दो बाइट्स को गोल्फ में बदल {a+=i;}सकते हैंa+=i;

— केविन क्रूज़सेन

1

@KevinCruijssen चीयर्स, विश्वास नहीं कर सकता कि मैं चूक गया! मैंने 'मैजिक नंबर' की कोशिश करने और उसे खोजने के लिए एक स्क्रिप्ट लिखी, जो मुझे 0 और 25 के बीच अद्वितीय मूल्य प्रदान करेगी, लेकिन सबसे अच्छा मैं 24 कर सकता था, इसलिए अंत में यदि कथन।

— ल्यूक स्टीवंस

1

हम्म btw, तुम जावा 8 का उपयोग कर रहे के बाद से, आप कर सकते हैं भी गोल्फ char g(String s)के लिए s->। मैंने आपके TIO को यह दिखाने के लिए संशोधित किया है कि यह कैसे करना है, यदि आप केवल जावा 7 विधियों के लिए उपयोग किए जाते हैं।

— केविन क्रूज़सेन

धन्यवाद, मुझे कभी नहीं लगा कि आप ऐसा कर सकते हैं, मैं अपना सबमिशन (फिर से!) अपडेट करूंगा

— ल्यूक स्टीवंस

हाहाहा, आप मुझे बता सकते हैं कि मैं नया हूँ

— ल्यूक स्टीवंस

5

पायथन 3, 132 99 96 बाइट्स

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

इसे ऑनलाइन आज़माएं!

शानदार ढंग से गोल्फ नहीं हुआ, लेकिन मुझे लगा कि मैं इसे एक मौका दूंगा।

^{TF33 द्वारा किए गए संशोधनों के लिए -33 बाइट्स धन्यवाद।

-3 बाइट्स के findबजाय indexओव्यू के लिए धन्यवाद का उपयोग करके ।}

— LyricLy
स्रोत

आप 6 बाइट्स का उपयोग करके बचा सकते हैं sum(map(ord,m)), साथ ही मैंने 128 बाइट्स के लिए एरीथा फ्रैंकलिन को

— 9

और आप chr(97+...)इसके बजाय का उपयोग कर सकते हैं ascii_lowercase: 99 बाइट्स

— TFeld

1

एक स्पष्टीकरण के बारे में क्या?

— मत्स्येमन

3

एक स्पष्टीकरण: sum(map(ord,m))स्ट्रिंग में वर्णों के ASCII मूल्यों को जोड़ता है m(702–1506 सीमा में पूर्णांक देता है)। फिर बुला chrयह है कि संख्या के साथ एक (यूनिकोड) चरित्र में बदल देता है: chr(702)है ʾ करने के लिए chr(1506) = עके बीच में और बहुत। यह समाधान बस इस चरित्र को सभी संभव (26) ऐसे वर्णों की सूची में देखता है ताकि सूचकांक (026) प्राप्त किया जा सके, फिर ASCII कोड 97 + के साथ वर्ण लौटाता है ताकि सूचकांक (इसलिए 'a' से 'z')।

— श्रीवत्सआर

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या इसे आज़माएं ।

— टाइटस
स्रोत

2

Aretha Franklin और पॉल मेकार्टनी दोनों Wआपके परीक्षण मामलों पर आउटपुट करते हैं, और कोई Xआउटपुट नहीं है। पता नहीं अगर यह कोड में एक त्रुटि है या सिर्फ यह ऑनलाइन रूपांतरण की कोशिश :)

— क्रेज़ीलॉबिन

1

@ crazyloonybin प्रतिस्थापन टाइपो तय। इशारा करने के लिए धन्यवाद।

— टाइटस

तो मैं इसे कैसे चलाऊं? आपका 'यह ऑनलाइन प्रयास करें' कोड <?=भाग का उपयोग नहीं करता है । और 'रन ऐज पाइप' से मुझे काम नहीं मिल रहा है। इसके अलावा, कमांड लाइन से इसे चलाने की कोशिश करने पर मुझे नोटिस मिलते हैं।

— nl-x

@ टिट्स: कोडगॉल्फ में आपको संपूर्ण फ़ंक्शन या एप्लिकेशन देना चाहिए जो वांछित आउटपुट उत्पन्न करता है (केवल)। मैं परिचित हूं <?=... इसलिए मेरा प्रश्न अभी भी है, मैं आपका कोड (कमांड लाइन से) कैसे चलाऊं? मैं इसे $argnकमांड लाइन में खिलाने में विफल रहा हूं ... मेरी सभी कोशिशें अब तक या तो कलाकृतियों को देती हैं, और अभी भी इसे चलाने के लिए अधिक कोड की आवश्यकता लगती है।

— nl-x

@ nl-x आपका PHP नोटिस देता है, ऐसा इसलिए है क्योंकि आपने इसे n विकल्प नहीं दिया है:echo <input> | php -nF <scriptfilename>

— टाइटस

4

पर्ल, 56 , 54 , 50 , 46 +1 (-पी) बाइट्स

~~$ = क्रिप्ट $ , DT; / .. (।) /? $ _ = $ 1; y / 01268ADIJNVW / adhilmnpqsux /~~

~~$ = क्रिप्ट $ , DT; / .. (।) /; $ = $ 1; y / 01268JVW / hlmpqsux /; $ = lc~~

~~$ = क्रिप्ट $ , एमओ; / .. (?) /; $ = $ 1; y / 035eft / AHPRXZ /; $ = lc ;~~

डॉम की टिप्पणी के लिए धन्यवाद 4 और बाइट्स को बचा सकता है, बेहतर आवश्यकताओं को पूरा करने के लिए अपरकेस में भी बदल गया।

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

यह ऑनलाइन की कोशिश करो

— नहुएल फौलीउल
स्रोत

अच्छा तरीका! मुझे लगता है कि आपको संपूर्ण कॉल करने योग्य फ़ंक्शन लिखने / स्कोर करने की आवश्यकता है?

— फेलिक्स पालमेन

@ फेलिक्सपालमेन, यह एक पर्ल प्रोग्राम है जिसे इनलाइन कहा जा सकता है: perl -pe '$_=crypt$_,mO;/..(.)/;$_=$1;y/035eft/AHPRXZ/;$_=lc'

— टियो के

अच्छा! एक समान दृष्टिकोण की तलाश कर रहा $1^$2था , लेकिन उपयोग करने के लिए नहीं सोचा था crypt... आप कुछ री-ऑर्डर के साथ 4 बाइट्स बचा सकते हैं: इसे ऑनलाइन आज़माएं!

— डोम हेस्टिंग्स

4

पायथन 2, 50 43 बाइट्स

नए संस्करण के लिए जेएफ़ को श्रेय

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)

— जेफ

@ जफ नाइस! मेरा अजगर ब्रूट फोर्स चेकर स्पष्ट रूप से पर्याप्त तेज नहीं था;)

— केएसएबी

3

रूबी, 63 बाइट्स

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

इनपुट के एएससीआई कोड जोड़ता है, उन्हें मोड 98 और फिर मॉड 66 nलेता है। 0.65 की सीमा में 26 अद्वितीय संख्याओं में से एक प्राप्त करने के लिए । विशाल हेक्साडेसिमल संख्या में 1इन 26 स्थानों में से प्रत्येक में एक बिट होता है , इसलिए इसे अधिकारपूर्वक स्थानांतरित करके nहम इसमें 1..26 1बिट्स के साथ एक संख्या प्राप्त करते हैं। हम 1आस्की कोड जोड़कर बिट्स की गिनती करते हैं और मॉड 48 लेते हैं, फिर 64 जोड़ते हैं और एक ASCII कोड में परिवर्तित करते हैं।

परीक्षण कार्यक्रम

mapगायकों पत्र कोड और गायक मुद्रण के माध्यम से iterates। यह तब अक्षर कोड की एक सरणी देता है, जो यह 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"]

— स्तर नदी सेंट
स्रोत

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 डेटा को संपीड़ित करने में भयानक है, इसलिए मुझे लुकअप मैपिंग बनाने के लिए एक और तरीका तलाशना पड़ा। मैंने तीन इनपुट पत्रों पर कुछ फ़ंक्शन खोजने की कोशिश की, जिसके परिणामस्वरूप एक अद्वितीय मूल्य था जो एक मुद्रण योग्य एएससीआईआई मूल्य भी था ताकि मैं प्रति इनपुट एक चरित्र के स्ट्रिंग में मैपिंग को एम्बेड कर सकूं।

यह पता चलता है कि मैट्रिक्स [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।
ऑक्टेव-केवल 'A':'Z'खोज के बजाय तार्किक अनुक्रमण का उपयोग करके 3 बाइट्स सहेजे गए ।
मैट्रिक्स गुणन का उपयोग करके गुणकों का योग करके 6 बाइट्स सहेजे गए।

— टॉम बढ़ई
स्रोत

चतुर दृष्टिकोण, शायद बहुत चालाक? 53 बाइट्स, मेरे MATL उत्तर के आधार पर

— Sanchises

@ सेंचुरी संभवतः, लेकिन यह वह तरीका था जो मैं ツ_ (_) _ / ¯ के साथ आया था। एक अलग उत्तर के रूप में अपना संस्करण पोस्ट करने के लिए आपका स्वागत है।

— टॉम कारपेंटर

मुझे लगा, और मैं मानता हूं कि सबसे छोटे दृष्टिकोण की नकल करने की तुलना में अलग दृष्टिकोण रखना अधिक दिलचस्प है। मैं सिर्फ दृष्टिकोणों की तुलना करना चाहता था, मुझे लगता है कि आपका अधिक चतुर है, लेकिन मुझे लगता है कि डेटासेट सिर्फ एक आसान मॉड-आधारित दृष्टिकोण के लिए अनुमति देता है (यह सुनिश्चित नहीं है कि अगर यह एक संयोग या सांख्यिकीय संभावना है)

— Sanchises

3

जावास्क्रिप्ट (क्रोम), 102

नोट: दुर्भाग्य से यह क्रोम में ही काम करता है, क्योंकि पारसेन्ट में कार्यान्वयन-निर्भर सन्निकटन () (धन्यवाद @ अरनल्ड)

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

सबसे अच्छा हैश फ़ंक्शन 0 और 50 के बीच 26 अलग-अलग मान देता है, लेकिन मैंने एक अलग का उपयोग किया, 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
स्रोत

आप यह उल्लेख करना चाह सकते हैं कि यह केवल क्रोम पर काम करता है क्योंकि कार्यान्वयन-निर्भर सन्निकटन में parseInt()।

— Arnauld

@ अर्नुलद धन्यवाद, मुझे नहीं पता था।

— edc65

3

सी, 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पायथन की तरह एक स्ट्रिंग फ़ंक्शन प्रदान नहीं करता है । या करता है?

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

इसे ऑनलाइन आज़माएं!

hintजिनके मान ASCII कोड हैं उनके लिए रिटर्न देता है A .. Z।

— japh
स्रोत

2

जावास्क्रिप्ट, 98 बाइट्स

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

मैंने पाया कि उनमें से प्रत्येक के लिए नामों के दूसरे और चौथे वर्ण का संयोजन अद्वितीय है।

इसलिए, मैं के संयोजन के साथ एक स्ट्रिंग बनाता हूं 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

वोल्फ्राम भाषा (गणितज्ञ) , 101126 बाइट्स

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

+32Mathematica में सबसे छोटी हलचल हैशटेबल के लिए अग्रणी लगता है InputForm।

इसे ऑनलाइन आज़माएं!

— कीउ गण
स्रोत

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 बाइट्स को हटाने के बाद नए सिरे से।

यह बहुत लंबा है, लेकिन /// विभिन्न वर्णों को उदारतापूर्वक संभाल नहीं सकते हैं। दूसरे शब्दों में, /// regex का समर्थन नहीं करता है।

— user202729
स्रोत

0

एक्सेल, 96 बाइट्स

अन्य दृष्टिकोणों को आज़माने में बहुत समय बर्बाद होने के बाद, @Eduardo Paez के दृष्टिकोण को लागू किया है:

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

— Wernisch
स्रोत

26 गायक, 26 पत्र

कार्य

नियम

MATL , 28 बाइट्स

व्याख्या

पायथन 2 , 80 71 बाइट्स

6502 मशीन कोड रूटीन (C64), 83 बाइट्स

व्याख्या

टेस्ट सूट (C64 बुनियादी, dataलाइनों में मशीन कोड दिनचर्या युक्त )

पायथन 2 , 68 बाइट्स

जावास्क्रिप्ट, 138 132 वर्ण

सांकेतिक टुकड़ा

जावा (ओपनजेडके 8) , 128 126 115 113 बाइट्स

पायथन 3, 132 99 96 बाइट्स

PHP, 90 88 86 72 + 1 बाइट्स

पर्ल, 56 , 54 , 50 , 46 +1 (-पी) बाइट्स

पायथन 2, 50 43 बाइट्स

रूबी, 63 बाइट्स

ऑक्टेव , 85 83 80 74 बाइट्स

जावास्क्रिप्ट (क्रोम), 102

सी, 65 55 49 बाइट्स

जावास्क्रिप्ट, 98 बाइट्स

वोल्फ्राम भाषा (गणितज्ञ) , 101126 बाइट्स

///, 390 231 बाइट्स

एक्सेल, 96 बाइट्स

टेस्ट सूट (C64 बुनियादी, `data`लाइनों में मशीन कोड दिनचर्या युक्त )