टकराव: "नहीं" का अर्थ है "हाँ"

Question

यह कोड गोल्फ हाल ही के डेली डब्ल्यूटीएफ लेख से प्रेरित था जिसे आप सच नहीं संभाल सकते हैं! , जो एक स्ट्रिंग तुलना के रूप में लिखा है:

String yes = "YES";
if ((delay.hashCode()) == yes.hashCode())

स्टीव की टीम के लिए यह परेशानी का कारण होगा अगर जावा का String.hashCodeतरीका सिर्फ उसी तरीके से लागू किया गया हो "YES".hashCode() == "NO".hashCode()। इसलिए, मैं यहाँ प्रस्तावित प्रस्ताव है:

जितना संभव हो, कुछ वर्णों में लिखें, एक हैश फ़ंक्शन (मैं इसे कॉल करूँगा h) एक स्ट्रिंग पैरामीटर और पूर्णांक रिटर्न मान के साथ, जैसे कि h("YES")बराबर h("NO")।

बेशक, यह एक फ़ंक्शन के साथ करने के लिए तुच्छ होगा def h(s): return 0, जो हर स्ट्रिंग के लिए हैश टकराव बनाता है । इस चुनौती को और दिलचस्प बनाने के लिए, आपको निम्नलिखित अतिरिक्त नियम का पालन करना होगा:

की अन्य तीन या कम अपरकेस ASCII अक्षरों (से मिलकर 18 277 संभव तार ^[A-Z]{0,3}$), वहाँ होना चाहिए कोई हैश टकराव।

स्पष्टीकरण (हेइको ओबर्डिएक द्वारा इंगित): इनपुट स्ट्रिंग में वर्णों के अलावा अन्य हो सकते हैं A-Z, और आपके कोड को मनमाने तार करने में सक्षम होना चाहिए। (आप कर सकते हैं, हालांकि, मान लेते हैं कि इनपुट है एक चरित्र स्ट्रिंग के बजाय एक नल पॉइंटर या कुछ अन्य डेटा प्रकार का ऑब्जेक्ट।) हालांकि, यह कोई बात नहीं क्या वापसी मान तार कि मेल न खाने वाले है ^[A-Z]{0,3}$जब तक, यह एक पूर्णांक है।

इसके अलावा, इस समारोह के इरादे को पूरा करने के लिए:

आपके कोड में वर्ण या स्ट्रिंग साहित्यिक के भीतर 'Y', 'E', 'S', 'N', या 'O' (या तो ऊपरी- या लोअरकेस में) कोई भी अक्षर शामिल नहीं होना चाहिए।

बेशक, इस प्रतिबंध भाषा कीवर्ड पर लागू नहीं होता है, तो else, returnआदि ठीक कर रहे हैं।

Comments

यह इस प्रकार की मदद नहीं करता है कि हम अभी भी YESNOइस विशिष्ट अपवाद की जांच करने के लिए संख्यात्मक ASCII मूल्यों का उपयोग कर सकते हैं।

— जो Z.

: लेख एक पढ़ना "कारणों के लिए" हास्य याद नहीं नहीं कर सकते threewordphrase.com/pardonme.gif

— एंटोनियो Ragagnin

Answer 1

GolfScript: 19 वर्ण (नामांकित फ़ंक्शन के लिए 24 वर्ण)

26base.2107=59934*+

यह फंक्शन की बॉडी है। इसे एक नामित फ़ंक्शन को सौंपने में hपाँच और वर्ण लगते हैं:

{26base.2107=59934*+}:h;

(अंतिम अर्धविराम को छोड़ा जा सकता है, यदि आपको स्टैक पर पड़े कोड की एक प्रति छोड़ने का मन नहीं है।)

हैश समारोह की मूल है 26base, जो योग की गणना करता है (26 ^{एन - कश्मीर} · एक _{कश्मीर} , कश्मीर = 1 .. n ), जहां n इनपुट में वर्णों की संख्या है और एक _{कश्मीर} की ASCII कोड को दर्शाता है कश्मीर वें इनपुट चरित्र। अपरकेस ASCII अक्षरों से युक्त इनपुट के लिए, यह एक टक्कर-मुक्त हैश फ़ंक्शन है। बाकी कोड 2107 (हैश कोड NO) के परिणाम की तुलना करता है और, यदि वे समान हैं, तो 2701 + 59934 = 62041, हैश कोड प्राप्त करने के लिए 59934 जोड़ता है YES।

उदाहरण के आउटपुट के लिए, परीक्षण मामलों के साथ यह ऑनलाइन डेमो देखें ।

Comments

आपने यह कैसे परीक्षण किया? मुझे सिर्फ टक्कर का एक गुच्छा मिला । उदाहरण: h('DXP') == h('KK') == 65884।

— nnonneo

(आप क्या लिखा है, मेरा परीक्षण प्रयोजनों के लिए के अजगर बराबर: lambda w:sum(ord(c)*26**i for i,c in enumerate(reversed(w*9)))%102983)

— nneonneo

@nneonneo: जाहिर है, बहुत अच्छी तरह से नहीं। मुझे लगा कि मैंने तीन-अक्षर-या-कम इनपुट का पूरा सेट उत्पन्न किया है, उन सभी को हैश किया है और जाँच की है कि इनपुट के सेट की तुलना में हैश के सेट में एक तत्व कम था। जाहिर है, मेरे टेस्ट हार्नेस में एक बग था। :-( मैं जब तक / जब तक मैं छोटे को ठीक नहीं कर सकता / सकती हूं, मूल 19-चार संस्करण में वापस आ

— जाऊंगा

Answer 2

32-बिट पायथन 2.x (19)

hash(w*9)%537105043

आरएसए एक अर्धचालक मापांक का उपयोग करता है, और यह इसे सुरक्षित बनाता है, इसलिए मेरे हैश एल्गोरिथ्म के साथ एक का उपयोग करना निश्चित रूप से इसे और बेहतर बनाना चाहिए! ¹

यह एक शुद्ध गणित कार्य है, सभी तारों के लिए काम करता है (नर्क, किसी भी धुरी पायथन ऑब्जेक्ट के लिए काम करता है), और इसमें कोई सशर्त या विशेष आवरण नहीं होता है! 32-बिट पायथन को आमतौर पर उन python-32अधिकांश प्रणालियों के रूप में कहा जा सकता है जिन्होंने दोनों को ² स्थापित किया है ।

मैंने इसका परीक्षण किया है, और यह 18,279 3-अक्षर-या-कम अपरकेस स्ट्रिंग्स के लिए 18,278 विभिन्न मान लौटाता है। इसे एक फंक्शन में असाइन करने में 11 और बाइट्स लगते हैं:

h=lambda w:hash(w*9)%537105043

और h('YES') == h('NO') == 188338253।

64-बिट पायथन 2.x (19)

hash(w*2)%105706823

ऊपर जैसा सौदा।

---

इन नंबरों के साथ आने के लिए, थोड़ा सा मॉड्यूलर गणित का इस्तेमाल किया गया था। मैं एक समारोह fऔर एक मापांक की तलाश कर रहा था nजैसे कि hash(f('YES')) % n == hash(f('NO')) % n। यह परीक्षण के बराबर है जो nविभाजित होता है d = hash(f('YES')) - hash(f('NO')), अर्थात हमें केवल dउचित मूल्यों के लिए कारकों की जांच करनी है n।

आदर्श nएक जन्मदिन विरोधाभास टक्कर की संभावना को कम करने के लिए 20000 ** 2 के पड़ोस में है। फ़ंक्शन के सभी विकल्पों के nसाथ d(वहाँ आमतौर पर कई नहीं हैं) और विभिन्न विकल्पों के साथ खेलकर, उपयुक्त परीक्षण और त्रुटि का एक सा पता चलता है f। ध्यान दें कि परीक्षण और त्रुटि की आवश्यकता केवल इसलिए है क्योंकि मैं nजितना संभव हो उतना छोटा बनाना चाहता था (गोल्फ के लिए)। यदि वह आवश्यकता नहीं थी, तो मैं dअपने मापांक के रूप में चुन सकता था , जो आमतौर पर पर्याप्त रूप से बड़ा होता है।

यह भी ध्यान दें कि आप इस ट्रिक को सिर्फ f(s) = s(पहचान फ़ंक्शन) का उपयोग करके नहीं खींच सकते हैं क्योंकि स्ट्रिंग के सबसे दाहिने पात्र में XORअंतिम हैश के साथ अनिवार्य रूप से एक रैखिक संबंध (वास्तव में एक रिश्ता) है (अन्य वर्ण बहुत अधिक गैर-रेखीय तरीके से योगदान करते हैं )। स्ट्रिंग की पुनरावृत्ति इसलिए सुनिश्चित करती है कि केवल सही चरित्र को बदलने के प्रभाव को खत्म करने के लिए तार के बीच अंतर को बढ़ाया जाता है।

---

¹ यह पेटेंट बकवास है।
² पायथन स्ट्रिंग हैशिंग प्रमुख संस्करण (2 बनाम 3) और बिटनेस (32-बिट बनाम 64-बिट) पर निर्भर करता है। यह प्लेटफॉर्म AFAIK पर निर्भर नहीं करता है।

Comments

आपको मेरा वोट मिल गया है। : D

— cjfaure

दुर्भाग्य से, यह नए हैश यादृच्छिककरण विशेषता के कारण पायथन के हाल के संस्करणों पर काम नहीं करता है।

— dan04

@ dan04: अजीब, मुझे लगा कि मैंने निर्दिष्ट किया है कि यह केवल पायथन 2.x के लिए था। मैंने इसे फिर से संपादित किया है।

— nnonneo

क्या मुझे पता है कि आपको ये मैजिक नंबर कैसे मिले? मैं देख रहा हूँ hash('YES'*9)है 34876679एक कारक के रूप है, जबकि hash('NO'*9)है 34876679+537105043एक कारक के रूप। लेकिन आप कैसे जानते हैं कि 537105043एक अच्छा मापांक था? यानी यह अन्य टकराव नहीं किया?

— एंटोनियो रागैगिन

@AntonioRagagnin: उत्तर में जोड़ा गया।

— nnonneo

Answer 3

पर्ल, 53 49 40 बाइट्स

sub h{hex(unpack H6,pop)-20047||5830404}

परीक्षा:

h('YES') = 5830404
h('NO')  = 5830404
Keys:   18279
Values: 18278

के लिए हैश मान YESऔर NOएक ही कर रहे हैं और वहाँ 18,279 तार कर रहे हैं ^[A-Z]{0,3}$, जो टकराव के लिए केवल टकराव के अलावा स्वतंत्र हैं YESऔर NO।

Ungolfed:

sub h {
    hex(unpack("H6", pop())) - 20047 || 5830404;
    # The argument is the first and only element in the argument array @_.
    # "pop" gets the argument from array @_ (from the end).
    # The first three bytes of the argument or less, if the argument
    # is shorter, are converted to a hex string, examples:
    #   "YES" -> "594553"
    #   "NO"  -> "4e4f"
    # Then the hex string is converted to a number by function "hex":
    #   0x594553 = 5850451
    #   0x4e4f   =   20047
    # The value for "NO" is subtracted, examples:
    #   case "YES": 5850451 - 20047 = 5830404
    #   case "NO":    20047 - 20047 =       0
    # If the argument is "NO", the subtraction is zero, therefore
    # 5830404 is returned, the result of "YES".
}

# Test
my %cache;
sub addcache ($) {$cache{$_[0]} = h($_[0])}

# Check entries 'YES' and 'NO'
addcache 'YES';
addcache 'NO';
print "h('YES') = $cache{'YES'}\n";
print "h('NO')  = $cache{'NO'}\n";

# Fill cache with all strings /^[A-Z]{0-3}$/
addcache '';
for my $one (A..Z) {
    addcache $one;
    for (A..Z) {
        my $two = "$one$_";
        addcache $two;
        for (A..Z) {
            my $three = "$two$_";
            addcache $three;
        }
    }
}
# Compare number of keys with number of unique values
my $keys = keys %cache;
my %hash;
@hash{values %cache} = 1 x $keys;
$values = keys %hash;
print "Keys:   $keys\n";
print "Values: $values\n";

पुराना संस्करण, 49 बाइट्स

चूंकि नया एल्गोरिदम थोड़ा अलग है, इसलिए मैं पुराने संस्करण को रखता हूं।

sub h{($_=unpack V,pop."\0"x4)==20302?5457241:$_}

परीक्षा:

h('YES') = 5457241
h('NO')  = 5457241
Keys:   18279
Values: 18278

Ungolfed:

sub h {
    $_ = unpack('V', pop() . ($" x 4);
        # pop():  gets the argument (we have only one).
        # $" x 4: generates the string "    " (four spaces);
        #   adding the four spaces ensures that the string is long
        #   enough for unpack's template "V".
        # unpack('V', ...): takes the first four bytes as
        #   unsigned long 32-bit integer in little-endian ("VAX") order.
    $_ == 20302 ? 5457241 : $_;
        # If the hash code would be "NO", return the value for "YES".
}

संपादन:

• "\0"भरण बाइट के रूप में उपयोग करने से तुलना में 4 बाइट बचाता है $"।

Comments

कहां से 5457241और कहां 20047से आए? आप इन नंबरों की गणना कैसे करते हैं? अग्रिम में धन्यवाद।

— AL

@ n.1: YESहेक्स में है 594553। 0x594553 = 5850451. NOहेक्स में है 4e4f। 0x4e4f = 20047.

— nneonneo

Answer 4

अजगर: 63

एक अविश्वसनीय रूप से लंगड़ा समाधान:

def h(s):
 try:r=int(s,36)
 except:r=0
 return(r,44596)[r==852]

यह आधार -36 संख्याओं के रूप में अल्फ़ान्यूमेरिक तारों की व्याख्या करके, और बाकी सब के लिए 0 लौटाता है। 852 (NO) के रिटर्न मान की जांच करने के लिए एक स्पष्ट विशेष मामला है, और इसके बजाय 44596 (YES) लौटाएं।

Comments

जब तक मुझे गलतफहमी न हो: यह कोड गोल्फ है, आपको यह मानने की अनुमति है कि इनपुट सटीक है। आप खाई try:और पूरी तीसरी पंक्ति को देख सकते हैं। आप प्रत्येक लॉजिकल लाइन को एक ही वास्तविक लाइन पर रखकर कुछ काटने से बचा सकते हैं, जो अर्धविराम द्वारा अलग किया गया है ( def h(s):r=int(s,36);return(r,44596)[r==852])

— भूमिगत संख्या

@undergroundmonorail: हैश फ़ंक्शन के लिए स्ट्रिंग पैरामीटर प्रश्न में प्रतिबंधित नहीं है । स्ट्रिंग्स के एक निश्चित वर्ग के लिए (तीन अपरकेस अक्षरों तक) हैश फ़ंक्शन के वापसी मूल्यों के बारे में प्रतिबंध है। हालांकि इससे कोई फर्क नहीं पड़ता कि अन्य स्ट्रिंग्स के लिए क्या लौटा है, अगर रिटर्न वैल्यू एक पूर्णांक है।

— हेइको ओबर्डिएक

मुझे आपके सरणी के बूलियन-इंडेक्सिंग पसंद हैं

— kratenko

Answer 5

शुद्ध बैश, 29 बाइट्स (फंक्शन बॉडी)

h()(echo $[n=36#$1,n-852?n:44596])

यह केवल इनपुट स्ट्रिंग को आधार 36 नंबर मानता है और दशमलव में परिवर्तित करता है, फिर विशेष NOमामले से संबंधित है।

आउटपुट:

$ ज ए
10
$ ह B
1 1
$ ज कैट
15,941
$ ज नहीं
44,596
ह $ यस
44,596
$ ज ZZZ
46655
$

Answer 6

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

h=->s{d=s.unpack('C*').join;d=~/896983|^7879$/?0:d}

परीक्षण कोड:

h=->s{d=s.unpack('C*').join;d=~/896983|^7879$/?0:d}

puts 'YES : '+h.call('YES').to_s # 0
puts 'NO : '+h.call('NO').to_s # 0
puts 'NOX : '+h.call('NOX').to_s # 787988
puts 'FNO : '+h.call('FNO').to_s # 707879
puts ''

values = Hash[]
n = 0
('A'..'Z').each{|c|
    values[c] = h.call(c)
    ('A'..'Z').each{|c2|
        values[c+c2] = h.call(c+c2)
        ('A'..'Z').each{|c3|
            values[c+c2+c3] = h.call(c+c2+c3)
            n += 1
        }
    }
}
puts 'tested '+n.to_s
duplicate = Hash.new()

values.each{|k, e|
    if duplicate.has_key?(e)
        puts 'duplicate : "'+k+'" = "'+duplicate[e].to_s+'" ('+e.to_s+')'
    else
        duplicate[e] = k
    end
}

आउटपुट:

YES : 0
NO : 0
NOX : 787988
FNO : 707879

tested 17576
duplicate : "YES" = "NO" (0)

Answer 7

जावास्क्रिप्ट ( ईएस 6 ) 54 बाइट्स

f=s=>[x.charCodeAt()for(x of s)].join('')^7879||897296

f('YES'); // 897296
f('NO'); // 897296
f('MAYBE'); // -824036582

Answer 8

जावा - 94 77

int h=new BigInteger(s.getBytes()).intValue();return Math.abs(h-(h^5835548));

unrolled:

int hashCode(String s) {
    int h = new BigInteger(s.getBytes()).intValue();
    return Math.abs(h - (h ^ 5835548));
}

कथा - के लिए f(s) = BigInteger(s.getBytes()):

• f("YES") xor f("NO") = 5835548
• इसलिए f("YES") xor 5835548 = f("NO")
• तो f("YES") - (f("YES") xor 5835548) = f("NO") - (f("NO") xor 5835548)क्या मैं सही हूं?

Comments

क्या आप BigInteger को इनलाइन नहीं कर सकते?

— mafu

@mafutrct - हाँ! धन्यवाद।

— OldCurmudgeon

Answer 9

सीजेएम, 15 बाइट्स

q42b_*81991617%

नीचे GolfScript समाधान के रूप में काम करता है। इसे ऑनलाइन आज़माएं।

---

GolfScript, 17 बाइट्स

42base.*81991617%

यह दृष्टिकोण nneonneo और Ilmari Karonen के उत्तरों पर आधारित है ।

यह काम किस प्रकार करता है

42base    # Interpret the input string as a base 42 number.
          # "YES" is [ 89 69 83 ] in ASCII, so it becomes 42 * (42 * 89 + 69) + 83 = 159977.
          # "NO" is [ 78 79 ] in ASCII, so it becomes 42 * 78 + 79 = 3355.
          #
.*        # Square. "YES" becomes 25592640529, "NO" becomes 11256025.
          #
81991617% # "YES" becomes 11256025.

एक एल्गोरिथ्म चुनना

हम शुरू करते हैं {b base}:h, यानी, इनपुट स्ट्रिंग को आधार-बी नंबर माना जाता है। जब तक b > 25, hअप्रभावी है।

अगर हम hनिम्नलिखित तरीके से संशोधित करते हैं , तो हम "YES" और "NO" स्ट्रिंग्स के लिए एक टक्कर प्राप्त करते हैं : {x base n}:hजहां nएक भाजक है "YES" h "NO" h -।

दुर्भाग्य से, इसका मतलब है कि हम इसके लिए एक टकराव भी प्राप्त करेंगे, जैसे, YETऔर NP। इसे रोकने के लिए, हमें मापांक लेने से पहले आधार-बी संख्या को एक गैर-रैखिक फैशन में संशोधित करना होगा।

गोल्फस्क्रिप्ट में इसे पूरा करने का सबसे छोटा तरीका आधार-बी संख्या को खुद से गुणा करना है (यानी, इसे चुकता करना)। hअब है {base b .* n %}:h।

यह सब करने के लिए उपयुक्त मान मिल रहा है bऔर n। हम इसे क्रूर बल द्वारा पूरा कर सकते हैं:

for((b=26;b<100;b++)){
    P=($(golfscript <<< "['YES' 'NO']{$b base.*}/-" | factor | cut -d\  -f 2-))

    for n in $(for((i=0;i<2**${#P[@]};i++)){
        for((n=1,j=0;j<${#P[@]};n*=${P[j]}**((i>>j)&1),j++)){ :;};echo $n;} | sort -nu);{
            [[ $n -ge 18277 && $(echo -n '' {A..Z}{,{A..Z}{,{A..Z}}} |
                golfscript <(echo "' '/[{$b base.*$n%}/].&,")) = 18278 ]] &&
            echo $b $n && break
    }
}

इसके लिए सबसे कम संभव मान b nहैं:

37 92176978
42 81991617

परिक्षण

$ echo -n '' {A..Z}{,{A..Z}{,{A..Z}}} |
     golfscript <(echo '{42base.*81991617%}:h;" "/{.`"\t"+\h+puts}/') |
     sort -k 2n |
     uniq -Df 1
"NO"    11256025
"YES"   11256025

Answer 10

जावास्क्रिप्ट (ईएस 6) - 38 अक्षर (33 चार फंक्शन बॉडी)

h=s=>(a=btoa(s))=="WUVT"|a=="Tk8="||+s

परीक्षण के मामलों:

var l = console.log;
l(  h("YES")  );                // 1
l(  h("NO")  );                 // 1
l(  h("ABC")  );                // NaN     
l(  h("WIN")  );                // NaN
l(  h("YES") === h("NO")  );    // true
l(  h("ABC") === h("WIN")  );   // false
l(  h("WIN") === h("YES")  );   // false

l(  NaN === NaN  );             // false

व्याख्या:

सबसे पहले, मैं आपको NaNजावास्क्रिप्ट में - "नॉट ए नंबर" से मिलवाता हूँ । यह एक संख्या है:

typeof NaN  // number

बिलकुल इसके जैसा:

typeof 42   // number

इसकी खास बात यह है कि यह कभी भी अपनी बराबरी नहीं करता है । 1यदि स्ट्रिंग है YESया NO, और NaNकिसी भी अन्य स्ट्रिंग के लिए मेरा फ़ंक्शन लौटाता है ।

इसलिए, यह नियमों को नहीं तोड़ता है, क्योंकि किसी भी अन्य स्ट्रिंग के लिए कोई हैश टकराव नहीं होगा;) ( NaN !== NaNपरीक्षण मामलों में ऊपर दिखाया गया है)।

और मेरा सपना सच हो गया: कोड लंबाई में बैश, पर्ल और रूबी की पिटाई!

अ-कोड कोड:

h =  // h is a function 
s => // s = string argument

( ( a = btoa(s) )  ==  "WUVT" | a == "Tk8=" )
        ^-- returns some value stored in `a`

यदि वह मान है "WUVT"या "Tk8=", वापसी 1। और, वापसी

+s // parseInt(s, 10)

जो होगा NaN।

Comments

NaN एक संख्या हो सकती है, लेकिन यह शब्द के किसी भी अर्थ में "पूर्णांक" नहीं है।

— पाओलो एबरमन

@ Pa @loEbermann विकी से , "एक पूर्णांक एक संख्या है जिसे एक भिन्नात्मक घटक के बिना लिखा गया है"। प्रश्न स्पष्ट रूप से यह नहीं कहता है कि पूर्णांक होना है ^\d+$। और जेएस NaNएक नंबर के रूप में व्यवहार करता है । आप इसे संख्या से गुणा कर सकते हैं, जोड़ सकते हैं, विभाजित कर सकते हैं, संख्याओं के साथ घटा सकते हैं। यह जावास्क्रिप्ट की एक विशेष संपत्ति है। इसका उपयोग करने में कोई बुराई नहीं है। जिसे हम नियमों का झुकना कहते हैं ;)

— गौरांग टंडन

मैं उपयोग कर सकता हूं Object.is()और दावा कर सकता हूं कि यह अभी भी एक टक्कर है ...

— user2428118

@ user2428118 मेरे ज्ञान के लिए Object.is लाने के लिए धन्यवाद। मैं यह कभी नहीं जानता था। लेकिन मैं आपको यह नोट करना चाहूंगा कि ओपी ==तुलना के लिए समानता ऑपरेटर ( ) का उपयोग करता है , जो गारंटी देगा कि "YES" या "NO" के अलावा किसी भी स्ट्रिंग के लिए कोई हैश टक्कर नहीं होती है।

— गौरांग टंडन

इस तथ्य को नज़रअंदाज़ करना कि दावा करना NaNटकराव के रूप में नहीं गिना जाता है, इस समाधान के NAमाध्यम से NPऔर नीचे के YEQमाध्यम से तार के साथ टकराव होता हैYET

— अंडरस्कोर

Answer 11

पायथन 92

n=int("".join(map(str,map(ord,raw_input()))))    # hashing function
print n if 1+(n**2-904862*n)/7067329057 else-1   # input validation

हैशिंग फ़ंक्शन ASCII वर्णों के क्रमिक मूल्यों को समेटता है, प्रिंट स्टेटमेंट यह सुनिश्चित करता है कि दो वांछित इनपुट टकराएं।

Answer 12

ECMAScript 6 (30 बाइट्स)

मैंने चर असाइनमेंट, रिटर्न और फंक्शन कीवर्ड से बचने की कोशिश की है, और यह सब बकवास से बचने का एक शानदार तरीका है (यह एक तरह से कार्यात्मक प्रोग्रामिंग जैसा दिखता है)। अन्य समाधानों के विपरीत, यह निर्भर नहीं करता है btoaया atob, जो ECMAScript 6 नहीं है, लेकिन HTML5 है। 0+की जरूरत है, इसलिए यह मनमाने तार को पार्स कर सकता है।

a=>parseInt(0+a,36)-852||43744

Comments

अच्छा! मुझे नहीं पता था कि उन्होंने parseInt के लिए अन्य आधार जोड़े हैं। आप हालांकि बहुत सारे बाइट्स काट सकते हैं। :)a=>parseInt(0+a,36)-852||43744

— अंडरस्कोर

@nderscore: सुझाव के लिए धन्यवाद। इसने वास्तव में मेरी पटकथा को बेहतर बनाया।

— कोनराड बोरोवस्की

Answer 13

जावा - 45 (या 62?)

मुझे नहीं पता कि जावा में प्रोग्राम चलाने के लिए किसी को क्या स्कोर देना है, क्या मुझे फंक्शन की परिभाषा को शामिल करने की जरूरत है? मेरे स्कोर को उचित रूप से संपादित और समायोजित करने के लिए स्वतंत्र महसूस करें। वर्तमान में मैं @OldCurmudgeon उत्तर के समान ही स्कोर कर रहा हूं। int h(String t){}यदि आवश्यक हो तो 17 जोड़ें :

int h=t.hashCode();return h*h*3%1607172496;

टेस्ट हार्नेस के साथ अपंग:

import static org.junit.Assert.*;

import java.util.*;

import org.junit.Test;

public class YesNo {
  @Test
  public void testHashValue() {
    YesNo yesNo = new YesNo();
    Set<Integer> set = new HashSet<>();

    assertEquals(yesNo.hash("YES"), yesNo.hash("NO"));

    set.add(yesNo.hash(""));
    for(char i = 'A'; i <= 'Z'; i++) {
      set.add(yesNo.hash("" + i));
      for(char j = 'A'; j <= 'Z'; j++) {
        set.add(yesNo.hash("" + i + j));
        for(char k = 'A'; k <= 'Z'; k++) {
          set.add(yesNo.hash("" + i + j + k));
        }
      }
    }
    assertEquals(18278, set.size());
  }

  int hash(String toHash) {
    int hashValue=toHash.hashCode();
    return hashValue*hashValue*3%1607172496;
  }
}

Answer 14

और शिथिल है ...

कन्वेयर, 145 चार्ट

 I
>#<
 26*)2**\88
 >========*
 ^    \ \+-
 ^=====#==<
5**222P:
5======<
5***26*)*(\P\:@e25*:*)4*,F
>==============#=========
             P,F

मूल रूप से यह कार्यक्रम किसी तरह के आधार पर 26 चीज़ों को करता है। उसके बाद यह जांचता है कि क्या हैश 12999 (YES का हैश कोड) के बराबर है और यदि ऐसा है तो 404 (NO का हैशकोड) प्रिंट करें, अन्यथा यह सिर्फ हैशकोड प्रिंट करेगा।

कन्वेयर मेरे द्वारा बनाई गई एक भाषा है जो वर्तमान में बीटा-चरणों में है, लेकिन कुछ उदाहरणों और स्रोत कोड के साथ एक दुभाषिया यहां पाया जा सकता है: https://github.com/loovjo/Conveyor

Answer 15

C # 4.5 (112 बाइट्स)

int h(string s){int code=s.Select((v,i)=>((int)v)<<(2*(i-1))).Sum();return(code|1073742225)|(code|-2147483569);}

भूमिगत # के कार्य का (?) संस्करण, C # में। एक 32-बिट पूर्णांक (केवल 4 वर्णों तक काम करता है) में स्ट्रिंग में बाइट्स को समाहित करता है, फिर क्रमशः "YES" और "NO" के लिए परिणाम के विरुद्ध परिणाम देता है, फिर ORS को एक साथ रखता है।

हालांकि यह किसी बिंदु पर टकरा सकता है, यह किसी भी ^ [AZ] {2,3} $ "YES" और "NO" के अलावा नहीं होना चाहिए।

Comments

आपके पास हैश फ़ंक्शन में कई और टकराव होंगे। आपका "हैश फंक्शन" अनिवार्य रूप से कॉनसैट में कई बिट्स को अनदेखा कर रहा है। सभी स्ट्रिंग जोड़े जो केवल उन बिट्स में भिन्न होते हैं, उनके पास समान हैश कोड होगा।

— पाओलो एबरमन

Answer 16

कोई टिप्पणी नहीं - 31 (फ़ंक्शन सामग्री: 26)

'=|*==|,,|+|"#|[|,  |+|-%3|]*|:

बहुत ही सरल उपाय। ;) किसी भी और सभी UTF-8 तार के लिए काम करता है।

शोषण: ' जाहिर है, समारोह है। सबसे पहले, यह जांचता है कि क्या *(यह इनपुट है) बराबर है |,,|+|"#|( |NO|)। यदि यह है, तो यह रिटर्न |, |+|-%3|( |YES|) - अन्यथा, यह सिर्फ रिटर्न करता है *।

Comments

मैंने बिना किसी टिप्पणी के कभी काम नहीं किया है, क्या आपके लिए यह संभव होगा कि आप अपने समाधान की व्याख्या करें जैसे कि अक्सर अपारदर्शी गोल्फस्क्रिप्ट, जे या एपीएल उत्तरों के साथ किया जाता है?

— काया

@ काया ओह, हाँ, क्षमा करें, मैं पोस्ट संपादित करूंगा।

— cjfaure

कोई माफी आवश्यक नहीं, मैं बस उत्सुक था कि यह कैसे काम करता है।

— काया

Answer 17

सी 54

h(char *c){int d=*(int*)c-20302;return d*(d-5436939);}

स्ट्रिंग को पूर्णांक में बदलें - "NO" और उसी मान + "NO" से गुणा करें - "NO" और "YES" के लिए 0 प्राप्त करने के लिए "YES" और निर्दिष्ट सीमा में किसी भी अन्य स्ट्रिंग के लिए गैर-शून्य।

विंडोज 7 मशीन पर सभी मूल्य अगर कोई एंडियन चिंताएं हैं।

Answer 18

स्टैक्स , 12 11 बाइट्स

ì≤ïøZ‼kESa←

इसे चलाएं और डीबग करें

बेस -36 के रूप में इनपुट का अनुवाद करता है, 852 घटाता है, फिर 0 को 43744 से बदल देता है। यह कोनराड के उत्कृष्ट समाधान का एक बंदरगाह है ।

Answer 19

कॉफ़ीस्क्रिप्ट - 36

के 1लिए वापस जाना चाहिए YESऔर NO, और जो कुछ भी बकवास atobहै वह सब कुछ के लिए पैदा करता है जो कि बेस 64 स्ट्रिंग नहीं है।

h=(s)->_=atob s;_ in["`D","4"]&&1||_

जावास्क्रिप्ट समतुल्य ( सीएस संकलक से जेएस कोड नहीं ):

function h( s ) {
    var _ = atob( s );

    if( _ === "`D" || _ === "4" )
        return 1;
    else
        return _;
}

Comments

"फ़ंक्शन का पूर्णांक रिटर्न मान होना चाहिए" - मुझे लगता है कि _जब इनपुट "YES" या "NO" नहीं है तो मैं आपका रिटर्न लौटा दूंगा।

— गौरांग टंडन

Answer 20

यहाँ एक सुपर लंगड़ा है। तो यह लंगड़ा नहीं है

पायथन 2.7 - 79 बाइट्स

def h(s):n=sum(100**i*ord(c)for i,c in enumerate(s));return (n-7978)*(n-836989)

सबसे पहले हमें (प्रत्येक वर्ण का अस्की मान) * 100 ^ (स्ट्रिंग में उस वर्ण की स्थिति) का योग मिलता है। फिर हम अपना अंतिम उत्तर प्राप्त करने के लिए गुणा करें (वह परिणाम - 78 ९ multip)) और (वह परिणाम - 9३६ ९ that ९)। 7978 और 836989 पहले YES के "YES" और "NO" के परिणाम हैं, इसलिए YES और NO के लिए हम 0 से गुणा कर रहे हैं।

यह कोई टकराव नहीं होना चाहिए? मैं 18000 संभावित प्रतिपक्षों के खिलाफ परीक्षण की तरह महसूस नहीं करता हूं, लेकिन अगर कोई अनजाने टकराव था तो मैं उस पर एक और 0 फेंक सकता हूं 100और फिर वास्तव में कोई टक्कर नहीं होनी चाहिए।

निराश है कि मैं इसके lambdaलिए उपयोग नहीं कर सकता , लेकिन मैं पूरी गणना दो बार नहीं करना चाहता था इसलिए मुझे इसे एक चर पर सहेजना पड़ा।

कृपया इसे जीतने न दें। यह सुपर लंगड़ा है और मैं इसके लायक नहीं हूं।

Comments

"कोई अन्य टकराव नहीं" आवश्यकता को पूरा नहीं करता है: 18277-स्ट्रिंग सेट में से केवल 18012 अद्वितीय हैश हैं जो टकराव नहीं होने चाहिए।

— dan04

@dan लानत, मुझे

— अंडरग्राउंडमोरल

@ मुझे काम करने के लिए नहीं मिल सकता है। हो सकता है कि एल्गोरिथ्म में कुछ गड़बड़ हो। मैं इसे हटाना नहीं चाहता क्योंकि किसी और को पता चल सकता है कि क्या गलत है, लेकिन मैं एक नोट डालूंगा

— भूमिगत

यह मेरे लिए काम करता है, h = lambda s: (हैश (s) [phone]) * (हैश) -480644903)

— लुकस

जैसा कि हैश फ़ंक्शन को आपके जैसे ही परिभाषित किया गया था, लेकिन 99 ** i * int (c, 36) के साथ

— लुकास